Ruby (język programowania)

Z Wikipedii

Ruby
Pojawienie się	1995
Paradygmat	wieloparadygmatowy
Typowanie	dynamiczne (duck typing)
Implementacje	Ruby MRI, YARV, JRuby, Rubinius
Aktualna wersja stabilna	1.9.0 (26 grudnia 2007
Twórca	Yukihiro Matsumoto
Licencja	Ruby license], 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.

[edytuj] 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.

Najnowsza stabilna wersja Ruby to 1.8.7, wydana 31 maja 2008 roku. Kolejna wersja, 1.9, jest w trakcie rozwoju. Docelowo ma poprawić obsługę Unicode i poprawić wydajność interpretera, dzięki wprowadzeniu nowego mechanizmu o nazwie YARV (ang. Yet Another Ruby VM).

[edytuj] 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.

[edytuj] Cechy szczególne

Ruby posiada:

• prostą składnię
• 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.

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 liczy ilość 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.

[edytuj] Przykłady

[edytuj] 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")

[edytuj] 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")

[edytuj] Lambda-wyrażenia

W Ruby można konstruować anonimowe funkcje za pomocą lambda-wyrażeń. Wywołuje się je za pomocą metody call.

add2 = lambda {|x| x+2}
 
print add2.call(10), "\n"
 
def addX(x)
    lambda {|y| y+x}
end
 
add3=addX(3)
print add3.call(10), "\n"

[edytuj] Domknięcia

Każde lambda-wyrażenie 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 lambda-wyrażenia).

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

[edytuj] 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

[edytuj] 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]

[edytuj] 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"

[edytuj] 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

[edytuj] Linki zewnętrzne

Zobacz publikację na Wikibooks:
Ruby

[edytuj] Strony o Ruby

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

[edytuj] Pomoce do nauki

• Programming Ruby: The Pragmatic Programmer's Guide - książka na temat Ruby'ego dostępna w Internecie (ang.) (klasyczna pozycja nazywana Pickaxe - w nawiązaniu do kilofa widniejącego na okładce. Wydanie I.)
• Wiki na temat języka Ruby (ang.)
• Ruby on Rails - platforma tworzenia aplikacji webowych w języku Ruby (en)
• Polska społeczność Ruby On Rails (pl)
• Ruby on Rails PL - polski serwis poświęcony Ruby on Rails (pl)
• Wprowadzenie do języka Ruby (pl)