Ruby (język programowania)

Z Wikipedii

Oficjalne logo języka Ruby.

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

1 Rozwój języka
2 Składnia
3 Cechy szczególne
4 Przykłady
5 Linki zewnętrzne
- 5.1 Strony o Ruby
- 5.2 Pomoce do nauki

[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.6, wydana 12 marca 2007 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 Perl, Smalltalk, Python, CLU, Eiffel czy LISP. 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ą wyjątkowo małe - ten sam program, który w C czy Javie zajmie setki linijek, w Ruby czy Perlu zajmie zwykle kilkadziesiąt. Ruby jest prawdopodobnie jedynym językiem ogólnym, w którym programy są zazwyczaj mniejsze niż analogiczne programy w Perlu, zachowując przy tym czytelność. Zawdzięcza to głównie 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 maszyn 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