Ruby (język programowania)

Z Wikipedii, wolnej encyklopedii
Skocz do: nawigacja, szukaj
Ruby
Logo języka
Logo języka
Pojawienie się 1995
Paradygmat wieloparadygmatowy
Typowanie dynamiczne (duck typing)
Implementacje Ruby MRI, JRuby, Rubinius, IronRuby, MagLev, MacRuby, RubyMotion, mruby
Aktualna wersja stabilna 2.1.4 / 27 października 2014; 30 dni temu[1]
Aktualna wersja testowa {{{wersja testowa}}}
Twórca Yukihiro Matsumoto
Licencja Ruby, GNU GPL
Platforma sprzętowa wieloplatformowy
Platforma systemowa wieloplatformowy
http://www.ruby-lang.org/

Ruby (wym. /ˈru:bi/)[2]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[edytuj | edytuj kod]

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

24 lutego 2013 została wydana wersja 2.0.0[3]

Składnia[edytuj | edytuj kod]

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

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

Programy pisane w Ruby charakteryzują się wysoką przenośnością pomiędzy platformami (istnieją implementacje na wiele systemów Uniksowych, DOS, Windows, 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[edytuj | edytuj kod]

Zmienna liczba argumentów funkcji[edytuj | edytuj kod]

W Rubym przekazywanie zmiennej liczby argumentów do funkcji odbywa się następująco: 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[edytuj | edytuj kod]

Argumenty funkcji mogą mieć domyślne wartości. W poniższym przykładzie pierwszy parametr - greeted - ma nadpisaną wartość "world", a drugi - greeting - zostaje z domyślnym "Hello".

def greet(greeted="world",greeting="Hello")
    greeting + ", " + greeted + "!\n"
end
 
print greet("people")

Wyrażenia lambda[edytuj | edytuj kod]

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} #Pierwotny zapis lambdy
 
# W Ruby 1.9 powyższy kod można zapisać także w innej wersji, pokazanej poniżej
 
add2 = ->(x) { x+2 } #Działa w Ruby od wersji 1.9
 
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[edytuj | edytuj kod]

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

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

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)

require 'continuation'
def fun arg
    p "fun called"
    callcc { |cc| $cc = 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[edytuj | edytuj kod]

W Ruby nawet bardzo skomplikowane dane można 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[edytuj | edytuj kod]

W każdym obiekcie metody pochodzące z klasy mogą być nadpisane bez stosowania jawnego dziedziczenia. Wynika to z faktu, że każdy obiekt jest instancją tzw. singleton class (nie mylić z wzorcem projektowym Singleton), która w drzewie hierarchii dziedziczenia znajduje się pomiędzy samym obiektem a jego jawną klasą[4].

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
#=> "Hello, world!\n"
y.greet
#=> "Goodbye, world!\n"

Zobacz też[edytuj | edytuj kod]

Przypisy

  1. Ruby 2.1.4 has been released (ang.). [dostęp 2014-11-10].
  2. dictionary.cambridge.org
  3. Wydanie Ruby 2.0.0 (dostęp 25.02.2013)
  4. Andrea Singh: Ruby's Eigenclasses Demystified (ang.). 2011-06-24. [dostęp 2013-10-08].

Linki zewnętrzne[edytuj | edytuj kod]

Wikibooks-logo.svg
Zobacz publikację na Wikibooks:
Ruby

Strony o Ruby[edytuj | edytuj kod]

Pomoce do nauki[edytuj | edytuj kod]