Materiały dla studentów Informatyki wydziału IET AGH w Krakowie

Transkrypt

1 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak Akademia Górniczo - Hutnicza w Krakowie, Katedra Informatyki Dr inż. Stanisław Polak 1 Przedmiot: Programowanie w języku Ruby Materiały dla studentów Informatyki wydziału IET AGH w Krakowie Organizacja przedmiotu Wykłady co tydzień, przez pierwsze 7 tygodni semestru Ćwiczenia laboratoryjne co dwa tygodnie, przez cały semestr Ocena końcowa obliczana na podstawie ilości punktów za wykonanie: Zestawu zadań programistycznych, przeznaczonych do wykonania na zajęciach Zestawu zadań domowych (dla chętnych) termin oddania: następne zajęcia Strona przedmiotu: ~polak/jtp/ruby/ Plan wykładów Framework Ruby on Rails Plan ćwiczeń 1. Składnia języka Ruby typizacja 2. Przetwarzanie tekstu, wyrażenia regularne 3. Programowanie funkcjonalne 4. Obiektowość, programy gem oraz rake 5. Interfejs Rack, podstawy języka dziedzinowego Sinatra 6. Framework Ruby on Rails podstawy 7. Framework Ruby on Rails wzorzec MVC Dr inż. Stanisław Polak 2 Przedmiot: Programowanie w języku Ruby Wstęp Plan prezentacji Krótko o Ruby Wstęp Zmienne Struktury kontrolne Typy danych Podprogramy Programowanie funkcjonalne Obiektowość Obsługa WWW Podstawy języka dziedzinowego Sinatra Źródło: Czy Ruby jest jakiś dziwny? Ruby nie jest dziwny. Ruby jest... oryginalny! Dr inż. Stanisław Polak 3 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 4 Przedmiot: Programowanie w języku Ruby

2 Wstęp Skrypty Wstęp Ogólna charakterystyka Uruchamianie kodu / skryptu Ruby Skryptowy język programowania Obiektowy Dynamicznie oraz silnie typowany Autor: Yukihiro Matsumoto (Matz) Logo Bazuje na językach: Perl, Python, Smalltalk, Eiffel, Ada oraz Lisp Szukałem języka potężniejszego od Perla i bardziej obiektowego od Pythona Wywiad z twórcą, Ruby jest prosty z wyglądu, ale bardzo skomplikowany w środku, tak jak ciało ludzkie. Wypowiedź na liście ruby-talk, # I m p l e m e n t a c j a unixowego p o l e c e n i a c a t 2 puts ARGF. read 3 # Znajdowanie sumy p i e r w s z y c h 10 l i c z b naturalnych, których kwadrat jest p o d z i e l n y p r z e z 5 4 ( 1.. Float : : INFINITY ). lazy. select { x x 2 % 5 == 0 }. take ( 1 0 ). inject (:+) Najpopularniejsze obszary zastosowań Aplikacje WWW Przetwarzanie tekstu Skrypty administratorskie Jednolinijkowce 1 $ ruby i pe $_. gsub!(" h1 "," h2 ") html Jednolinijkowiec 1 #! / u s r / b i n / env ruby 2 print " Hello World \n" 1 $ ruby e print " hello world \n" 2 hello world 3 $ ruby 4 print " Hello World \n" 5 Ctrl+D 6 Hello World 7 $ irb :001 > print " Hello World \n" 9 Hello World 10 => nil :002 > exit 12 $ ruby hello. rb 13 Hello World 14 $ chmod 755 hello. rb 15 $. / hello. rb 16 Hello World hello.rb Terminal Linux Dr inż. Stanisław Polak 5 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 6 Przedmiot: Programowanie w języku Ruby Skrypty Wstęp Uwagi ogólne Każda poprawna konstrukcja językowa, za wyjątkiem bloków, jest wyrażeniem Wyrażenia nie muszą kończyć się średnikiem lub innym separatorem Struktury zaczynają się zazwyczaj od jakiegoś słowa kluczowego, a kończą się słowem kluczowym end W wywołaniach oraz w definicjach metod nawiasy są opcjonalne Wszystko jest obiektem Zalecany styl kodowania / formatowania skryptów patrz: 1 $ irb :001 > => :002 > a = 1 5 => :003 > b = 2 ; c = 3 7 => :004 > d = :005 > 3 10 => :006 > e = 2 3\ :007 > 4 13 => 24 Skrypty Wstęp Konwencje nazewnicze dla funkcji / metod number.even?() string.upcase!() car.brand=( Fiat ) array.size() Dr inż. Stanisław Polak 7 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 8 Przedmiot: Programowanie w języku Ruby

3 Skrypty Wstęp Komentowanie kodu 1 # Ten ca ł y wiersz j e s t komentarzem 2 a = "#łań cuch znakowy " #Tu j e s t komentarz 3 a = /#wyra ż e n i e r e g u l a r n e / #A tu k o l e j n y komentarz 4 # 5 # Komentarz 6 # Ci ąg dalszy komentarza 7 # 8 9 =begin 10 Komentarz 11 Ci ąg dalszy komentarza 12 =end if a > 2 15 print "a jest wię ksze od 2\n" 16 =begin 17 Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod 18 tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, 19 quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo 20 consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse 21 cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat 22 non proident, sunt in culpa qui officia deserunt mollit anim id est laborum print " Ala ma kota \n" 25 =end 26 b = 2 27 end 28 Dr inż. Stanisław Polak 9 Przedmiot: Programowanie w języku Ruby Skrypty Wstęp Wczytywanie danych Wczytanie pojedynczej linii tekstu Skrypty Wstęp Wypisywanie danych 1 # t o s i s g e n e r a l l y i n t e n d e d to r e t u r n a human r e a d a b l e r e p r e s e n t a t i o n o f t h e o b j e c t, s u i t a b l e f o r end users. 2 # i n s p e c t, on t h e o t h e r hand, i s intended f o r debugging use, and s h o u l d r e t u r n a r e p r e s e n t a t i o n t h a t i s h e l p f u l to Ruby d e v e l o p e r s. The d e f a u l t i n s p e c t method, i n h e r i t e d from O b j e c t, s i m p l y c a l l s t o s. 3 #Źr ód ł o : David Flanagan, Yukihiro Matsumoto, The Ruby Programming Language 4 ######################### 5 print ( , [ 4, ], "8\ tdziewi ęć\n" ) 6 printf( "%e %s %s\n", , [ 4, ], "8\ tdziewi ęć" ) 7 puts ( , [ 4, ], "8\ tdziewi ęć\n" ) 8 p ( , [ 4, ], "8\ tdziewi ęć\n" ) Na wyjściu 1.23[4, 5.67]8 dziewięć e+00 [4, 5.67] dziewięć 1.23 [4, 5.67] "8\tdziewięć\n" dziewięć 1 $ irb :001 > puts => nil :002 > p => :003 > puts (123)? true : false => false :004 > p (123)? true : false => true Dr inż. Stanisław Polak 10 Przedmiot: Programowanie w języku Ruby Materiały dla studentów Informatyki wydziału IET AGH w Krakowie Skrypty Wstęp Wczytywanie danych Wczytanie wielu linii tekstu 1 puts ######################### 2 puts " Wprowad ź dane :" 3 dane = gets() 4 puts ######################### 5 puts " Wprowadzone dane :" 6 print dane 7 puts p dane 9 puts ######################### Na wyjściu ######################### Wprowadź dane: Ala ma kota i psa ######################### Wprowadzone dane: Ala ma kota i psa "Ala\tma kota i\tpsa\n" ######################### Na wyjściu ######################### Wprowadź dane: Ctrl+D ######################### Wprowadzone dane: nil ######################### Dr inż. Stanisław Polak 11 Przedmiot: Programowanie w języku Ruby 1 puts ############# 2 puts " Wprowad ź dane :" 3 while(dane = gets()) 4 puts ############# 5 puts " Wprowadzone dane :" 6 puts dane 7 puts p dane 9 puts ############# 10 puts " Wprowad ź dane :" 11 end Na wyjściu ############# Wprowadź dane: Ala ############# Wprowadzone dane: Ala "Ala\n" ############# Wprowadź dane: ma kota i psa ############# Wprowadzone dane: ma kota i psa "ma kota i\tpsa\n" ############# Wprowadź dane: Ctrl+D 1 puts ############# 2 puts " Wprowad ź dane :" 3 dane = $stdin. read() 4 puts ############# 5 puts " Wprowadzone dane :" 6 puts dane 7 puts p dane 9 puts ############# Na wyjściu ############# Wprowadź dane: Ala ma kota i psa Ctrl+D ############# Wprowadzone dane: Ala ma kota i psa "Ala\nma kota i\tpsa\n" ############# Dr inż. Stanisław Polak 12 Przedmiot: Programowanie w języku Ruby

4 Skrypty Wstęp Umieszczanie danych w skrypcie Skrypty Wstęp Umieszczanie danych w skrypcie Przykład zastosowania 1 puts DATA. read 2 END 3 puts " Ten kod nie zostanie wykonany " 4 Linia 2 5 Linia 3 Na wyjściu puts "Ten kod nie zostanie wykonany" Linia 2 Linia 3 1 #! / u s r / b i n /env ruby 2 require rdoc 3 if ARGV [ 0 ] == --man 4 manual = DATA. read 5 # html = RDoc : : Markup : : ToHtml. new ( RDoc : : O ptions. new ) 6 ansi = RDoc : : Markup : : ToAnsi. new ( ) 7 puts ansi. convert ( manual ) 8 end 9 END 10 = Name pmh convert. rb converts an OAI PMH document into the DOAJ format ; optionally also into the DBLP or PBN = SYNOPSIS pmh convert. rb [ help ] [ man ] [ version ] [ doajlogin username ] [ doajpass password ] [ startdate ] [ enddate ] == Examples pmh convert. rb+ Generate, in the current directory, DOAJ file for the entire period of time, i. e., for all ( input ) records 21 <tt>pmh convert. rb </tt> Generate, in the current directory, DOAJ file for a given period of time Author : : Stanis ł aw Polak ( mailto : polak@agh. edu. pl ) pmh-convert.rb Rysunek: Wyświetlanie podręcznika użytkownika z poziomu konsoli systemowej Dr inż. Stanisław Polak 13 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 14 Przedmiot: Programowanie w języku Ruby Skrypty Wstęp Bloki BEGIN oraz END Skrypty Wstęp Ładowanie skryptu 1 puts " Kod skryptu " 2 END { 3 puts " Ten ró wnie ż" 4 } 5 END { 6 puts " Ten kod jest wykonywany tuż po zako ń czeniu wykonywania kodu skryptu " 7 } 8 BEGIN { 9 puts " Ten kod jest wykonywany tuż przed rozpoczeciem wykonywania kodu skryptu " 10 } 11 BEGIN { 12 puts " Ten też" 13 } Na wyjściu 1 # Obliczanie sumy liczb wczytanych z klawiatury, aż do naci ś ni ę cia Ctrl+D 2 # n w h i l e ( $ = g e t s ) do 3 # t r e ś ć s k r y p t u 4 # end 5 $ ruby ne suma += $_. to_i ; BEGIN { suma = 0 }; END { puts suma } 6 1 #$ = 1\n 7 2 #$ = 2\n 8 10 #$ = 10\n 9 Ctrl+D Przykład użycia w jednolinijkowcu Ten kod jest wykonywany tuż przed rozpoczeciem wykonywania kodu skryptu Ten też Kod skryptu Ten kod jest wykonywany tuż po zakończeniu wykonywania kodu skryptu Ten również 1 if FILE == $PROGRAM NAME 2 #Zmienna FILE ma warto ś ć skrypt. rb 3 #Zmienna $PROGRAM NAME ma warto ś ć s k r y p t. rb 4 puts " Ten skrypt zosta ł uruchomiony z linii komend " 5 else 6 #Zmienna FILE ma warto ś ć skrypt. rb 7 #Zmienna $PROGRAM NAME ma warto ś ć i r b 8 puts " Ten skrypt zosta ł zał adowany z poziomu innego skryptu " 9 end skrypt.rb 1 $ irb : > load. / skrypt. rb 3 Ten skrypt zosta ł za ł adowany z poziomu innego skryptu 4 => true : > load. / skrypt. rb 6 Ten skrypt zosta ł za ł adowany z poziomu innego skryptu 7 => true :003 > require. / skrypt 9 Ten skrypt zosta ł za ł adowany z poziomu innego skryptu 10 => true :004 > require. / skrypt 12 => false 13 # $ export RUBYLIB=$HOME/ skrypty1 :$HOME / s k r y p t y 2 14 $LOAD_PATH 15 => [ "/home / polak / skrypty1 ", "/home / polak / skrypty2 ", "/ home / polak /. rvm / rubies /ruby / lib /ruby / site_ruby /2.2.0 ",... ] :005 > exit 18 $ ruby skrypt. rb 19 Ten skrypt zosta ł uruchomiony z linii komend Konsola irb Dr inż. Stanisław Polak 15 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 16 Przedmiot: Programowanie w języku Ruby

5 Narzędzia Wstęp Narzędzia Wstęp Ruby w systemie Linux Menedżer wersji Ruby Ruby Version Manager (RVM) 1 $ sudo apt get update 2 $ sudo apt get install git core curl zlib1g dev build essential libssl dev libreadline dev libyaml dev libsqlite3 dev sqlite3 libxml2 dev libxslt1 dev libgdbm dev libncurses5 dev automake libtool bison libffi dev 3 $ curl L https : / / get. rvm. io bash s stable 4 $ source /. rvm /scripts /rvm 5 $ echo "source ~/.rvm /scripts /rvm " >> /. bashrc 6 $ echo "gem : --no -ri --no -rdoc " > /. gemrc # Podczas i n s t a l a c j i gemów n i e b ę d z i e generowana / i n s t a l o w a n a dokumentacja 1 $ rvm get stable Instalacja Aktualizacja Interpreter Ruby 1 $ rvm install <nazwainterpretera> Instalacja 1 $ rvm list known #wyś wietlenie ( nazw ) dost ępnych i m p l e m e n t a c j i wraz z numerami i c h w e r s j i 2 $ rvm upgrade <nazwaimplementacji> # np. rvm upgrade ruby Aktualizacja 1 $ rvm use <nazwainterpretera> default #l u b rvm use x. x. x d e f a u l t Określanie domyślnego interpretera Ruby w systemie Linux Ważniejsze implementacje Implementacje w języku C (CRuby) MRI (ang. Matz s Ruby Interpreter) Używany w Ruby 1.8 Tworzone jest drzewo składniowe Korzysta z zielonych wątków YARV (Yet Another Ruby VM) Używany w Ruby 1.9 Wirtualna maszyna Ruby Korzysta z wątków natywnych; używa GIL (Global Interpreter Lock) Nie używa kompilatora JIT (Just-in-time) Instalacja 1 $ rvm install ruby 2 # l u b 3 $ rvm install x. x. x #i n s t a l u j e w e r s j ę o numerze x. x. x Inne JRuby Implementacja w Javie Używa wątków natywnych, brak GIL Używa kompilatora JIT Instalacja 1 $ rvm install jruby Rubinius Implementacja w Ruby oraz C++ Używa wątków natywnych, brak GIL Używa kompilatora JIT Instalacja 1 $ rvm install rbx Informacje o innych implementacjach Dr inż. Stanisław Polak 17 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 18 Przedmiot: Programowanie w języku Ruby Narzędzia Wstęp Ruby w systemie Linux Porównanie wydajności implementacji 1 def fibonacci ( n ) 2 if n < 2 3 return n 4 end 5 return fibonacci ( n 2) + fibonacci ( n 1) 6 end 7 ################# 8 def wą tki 9 i = 100 _000_ times. map do 11 Thread. new do _000_000. times { i = 1 } 13 end 14 end. each (&: join ) #Czekamy a ż w s z y s t k i e wą t k i zako ń cz ą p r a c ę 15 printf ( "Koń cowa warto ść i: %d\n", i ) 16 end funkcje.rb 1 require benchmark 2 load funkcje.rb 3 ################# 4 czas_wykonania = Benchmark. realtime do x 5 5. times { fibonacci ( 3 5 ) } 6 end 7 printf "Czas wykonania : %f\n", czas_wykonania 8 ################# 9 wą tki ( ) skrypt.rb 1 $ rvm use ruby $ ruby skrypt. rb 3 Czas wykonania : Koń cowa wartość i : 0 5 ############################################ 6 $ rvm use jruby #Java w e r s j a $ ruby skrypt. rb 8 Czas wykonania : Koń cowa wartość i : $ ruby X C skrypt. rb #Wył ą czona k o m p i l a c j a JIT 12 Czas wykonania : Koń cowa wartość i : ############################################ 15 $ rvm use rbx #LLVM w e r s j a $ ruby skrypt. rb 17 Czas wykonania : Koń cowa wartość i : $ ruby Xint skrypt. rb #Wył ą czona k o m p i l a c j a JIT 21 Czas wykonania : Koń cowa wartość i : Dr inż. Stanisław Polak 19 Przedmiot: Programowanie w języku Ruby Narzędzia Wstęp Ruby w systemie MS Windows MRI / YARV RubyInstaller http: //rubyinstaller.org/ JRuby Program pik Menedżer wersji Ruby add-ons/pik/ 1 > pik add C :\ Ruby187\bin 2 INFO : Adding : [ ruby ]1.8.7 p371 3 Located at : C :\ Ruby187\bin 4 5 > pik add C :\ Ruby193\bin 6 INFO : Adding : [ ruby ]1.9.3 p392 7 Located at : C :\ Ruby193\bin 8 9 > pik add C :\ Ruby200\bin 10 INFO : Adding : [ ruby ]2.0.0 p0 11 Located at : C :\ Ruby2000\bin 12 > pik list 13 ruby p ruby p ruby p0 16 > pik use ruby p0 17 > ruby v 18 ruby p0 ( ) [ i386 mingw32 ] 19 > pik use ruby p392 default 20 > pik default 21 > ruby v 22 ruby p392 ( ) [ i386 mingw32 ] Dr inż. Stanisław Polak 20 Przedmiot: Programowanie w języku Ruby ateriały dla studentów Informatyki wydziału IET AGH w Krakowie

6 Narzędzia Wstęp RubyGems Narzędzia Wstęp Tworzenie i generowanie dokumentacji Program rdoc Standardowy menedżer pakietów (gemów) Rubiego działa podobnie jak apt-get, emerge,... Dostępny wraz z Ruby 1.9 Przykłady użycia 1 gem install rails #z a i n s t a l u j gem Ruby on R a i l s 2 gem fetch rails #p o b i e r z gem Ruby on R a i l s, a l e go n i e i n s t a l u j 3 gem uninstall rails #usuń gem Ruby on Rails 4 gem list local #wyś w i e t l zainstalowane gemy 5 gem list remote #wy ś w i e t l d o s t ę pne gemy 6 gem search NAPIS remote #przeszukaj l i s t ę dost ę pnych gemów 7 gem rdoc all #stwó rz dokumentacj ę RDoc dla wszystkich gemów 8 gem cleanup #usuń s t a r e wersje zainstalowanych gemów 1 # The program t a k e s an i n i t i a l word o r p h r a s e from 2 # the command l i n e ( or in the absence of a 3 # p a r a m e t e r from t h e f i r s t l i n e o f s t a n d a r d 4 # i n p u t ). I n then r e a d s s u c c e s s i v e words or 5 # p h r a s e s from s t a n d a r d i n p u t and r e p o r t s whether 6 # t h e y a r e angrams o f t h e f i r s t word. 7 # 8 # Author : : Dave Thomas ( m a i l t o : dave@x. y ) 9 # Copyright : : Copyright ( c ) 2002 The Pragmatic Programmers, LLC 10 # License : : Distributes under the same terms as Ruby # This c l a s s h o l d s t h e l e t t e r s i n t h e o r i g i n a l 13 # word or phrase. The is anagram? method allows us 14 # to test i f subsequent words or phrases are 15 # anagrams o f t h e o r i g i n a l. 16 class Anagram # Remember t h e l e t t e r s i n t h e i n i t i a l word 19 def initialize ( text ) = letters_of ( text ) 21 end 22 # Test to see i f a new word contains the same 23 # l e t t e r s as t h e o r i g i n a l 24 def is_anagram?( text ) == letters_of ( text ) 26 end 27 # Determine the l e t t e r s in a word or phrase 28 # 29 # a l l l e t t e r s a r e c o n v e r t e d to l o w e r c a s e 30 # a n y t h i n g not a l e t t e r i s s t r i p p e d out 31 # t h e l e t t e r s a r e c o n v e r t e d i n t o an a r r a y 32 # the array i s sorted 33 # t h e l e t t e r s a r e j o i n e d back i n t o a s t r i n g 34 def letters_of ( text ) 35 text. downcase. delete ( ^a-z ). split ( ). sort. join 36 end 37 end tester = Anagram. new ( ARGV. shift gets ) 40 ARGF. each do text 41 puts " Anagram! " if tester. is_anagram? text 42 end anagram.rb 1 $ rdoc # G e n e r u j p l i k i. html 2 $ rdoc format=ri # G e n e r u j p l i k i. r i 3 $ rdoc format=pot # Generuj p l i k rdoc. pot Generowanie dokumentacji Dr inż. Stanisław Polak 21 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 22 Przedmiot: Programowanie w języku Ruby Narzędzia Wstęp Narzędzia Wstęp Wyświetlanie manuala Program ri 1 $ ri help 2 Usage : ri [ options ] [ names... ] 3 4 Where name can be : 5 6 Class Module Module : : Class 7 8 Class : : method Class#method Class. method method 9 10 gem_name : gem_name : README gem_name : History All class names may be abbreviated to their minimum unambiguous form. If a name 13 is ambiguous, all valid options will be listed A. matches either class or instance methods, while #method 16 matches only instance and : : method matches only class methods README and other files may be displayed by prefixing them with the gem name 19 they re contained in. If the gem name is followed by a : all files in the 20 gem will be shown. The file name extension may be omitted where it is 21 unambiguous For example : ri Fil 26 ri File 27 ri File. new 28 ri zip 29 ri rdoc : README Note that shell quoting or escaping may be required for method names containing 32 punctuation : ri Array. [ ] 35 ri compact \! To see the default directories ri will search, run : ri list doc dirs Debugowanie skryptu 1 a=1 2 b=2 3 c=3 4 puts a 5 puts b 6 puts c skrypt.rb 1 $ gem install byebug 2 $ byebug skrypt. rb 3 [1, 6 ] in /home /polak /skrypt. rb 4 => 1 : a=1 5 2 : b=2 6 3 : c=3 7 4 : puts a 8 5 : puts b 9 6 : puts c 10 ( byebug ) display a 11 1 : a = nil 12 ( byebug ) next [1, 6 ] in /home /polak /skrypt. rb 15 1 : a=1 16 => 2 : b= : c= : puts a 19 5 : puts b 20 6 : puts c 21 1 : a = 1 Debuger Byebug 1 $ ruby rdebug skrypt. rb #Za ł adowanie b i b l i o t e k i debug 2 Debug. rb 3 Emacs support available. 4 5 skrypt. rb : 1 : a=1 6 ( rdb : 1 ) list 7 [ 4, 5 ] in skrypt. rb 8 => 1 a=1 9 2 b= c= puts a 12 5 puts b 13 ( rdb : 1 ) display a 14 1 : a = 15 ( rdb : 1 ) break 3 16 Set breakpoint 1 at skrypt. rb :3 17 ( rdb : 1 ) cont 18 Breakpoint 1, toplevel at skrypt. rb :3 19 skrypt. rb : 3 : c= : a = 1 21 ( rdb : 1 ) p b ( rdb : 1 ) p c 24 nil 25 ( rdb : 1 ) next 26 skrypt. rb : 4 : puts a 27 1 : a = 1 28 ( rdb : 1 ) cont Dr inż. Stanisław Polak 23 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 24 Przedmiot: Programowanie w języku Ruby

7 Narzędzia Wstęp Zmienne Alternatywna konsola Ruby Program pry Wybrane cechy Przeglądanie kodu źródłowego Podświetlanie składni Przeglądanie dokumentacji System pomocy, na żywo Integracja powłoki poleceń (uruchamianie edytorów, uruchomianie git oraz rake z poziomu pry ) Możliwość debugowania kodu 1 a=1 2 binding. pry #p i e r w s z a pu ł apka 3 b=2 4 c=3 5 binding. pry #druga pu ł apka 6 puts a 7 puts b 8 puts c skrypt.rb 1 $ gem install pry #I n s t a l a c j a pry 2 $ pry 3 [ 1 ] pry ( main )> puts " Hello World " 4 Hello World 5 => nil 6 [ 2 ] pry ( main )> exit 7 $ ruby r pry skrypt. rb #Uruchomienie w t r y b i e,, debug 8 1 : a=1 9 => 2 : binding. pry #p i e r w s z a pu ł apka 10 3 : b= : c= : binding. pry #druga pu ł apka 13 6 : puts a 14 7 : puts b 15 [ 1 ] pry ( main )> a 16 => 1 17 [ 2 ] pry ( main )> b 18 => nil 19 [ 3 ] pry ( main )> Ctrl+D 20 From : / home / polak / skrypt. line 5 : : a= : binding. pry #p i e r w s z a pu ł apka 24 3 : b= : c=3 26 => 5 : binding. pry #druga pu ł apka 27 6 : puts a 28 7 : puts b 29 8 : puts c 30 9 : [ 1 ] pry ( main )> Definiowanie zmiennych 1 #s t a ł e 2 STALA=1 3 =>1 4 STALA=2 5 ( irb ) : 2 : warning : already initialized constant STALA 6 => 2 7 #d e f i n i o w a n i e zmiennych 8 a = 10 9 b = c = d = a, b, c, d = 10, 20, 30, #i d e n t y f i k a c j a typu 14 d. kind of? Integer 15 => true 16 d. class 17 => Fixnum 18 #zmiana typu 19 x = => x. class 22 => Fixnum 23 x = hello 24 => " hello " 25 x. class 26 => String 1 y = 20 2 => 20 3 y. to f 4 => to s #kod d z i e s i ą tkowy 6 => " " to s ( 2 ) #kod dwó jkowy 8 => " " to s ( 16) #kod s z e s n a s t k o w y 10 => " d431 " to s ( 8 ) #kod ósemkowy 12 => " " Konwersja wartości Dr inż. Stanisław Polak 25 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 26 Przedmiot: Programowanie w języku Ruby Zmienne Struktury kontrolne Zasięg zmiennych 1 x = 10 2 => 10 3 defined? x 4 => "local - variable " 5 $x = 10 6 => 10 7 defined? $x 8 => "global - variable " 9 loopcounter = LoopCounter = $welcome = " Welcome to Ruby " 12 gets 13 hello 14 => " hello \n" 15 $ 16 => " hello \n" 17 require English 18 => true 19 $LAST READ LINE 20 => " hello \n" 21 $$ 22 => = 0 = Stala=1 Instrukcja warunkowa if Wyrażenie if 1 if warunek [ then ] 2 kod... 3 [ elsif warunek [ then ] 4 kod... ]... 5 [ else 6 kod... ] 7 end Składnia 1 if 10 < 20 then 2 print "10 jest mniejsze niż 20" 3 end Przykład użycia 1 liczba = 5 2 znak = if liczba > 0 3 dodatni 4 elsif liczba < 0 5 ujemny 6 else 7 zero 8 end 9 znak 10 => " dodatni " Modyfikator if 1 kod if warunek Składnia 1 print "10 jest mniejsze niż 20" if 10 < 20 Przykład użycia Dr inż. Stanisław Polak 27 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 28 Przedmiot: Programowanie w języku Ruby

8 Instrukcja warunkowa unless Wyrażenie unless 1 unless warunek [ then ] 2 kod 3 [ else 4 kod ] 5 end 1 unless str. nil? 2 return str. length 3 end Składnia Przykład użycia Struktury kontrolne Modyfikator unless 1 kod unless warunek Składnia 1 return str. length unless str. nil? Przykład użycia Dr inż. Stanisław Polak 29 Przedmiot: Programowanie w języku Ruby Instrukcja wyboru Struktury kontrolne 1 ######### Forma 1 ######### 2 case wyra ż enie 3 [ when wyra ż enie [, wyra ż enie... ] [ then ] 4 kod ]... 5 [ else 6 kod ] 7 end 8 9 ######### Forma 2 ######### 10 case 11 [ when wyra ż enie_logiczne [, wyra ż enie_logiczne... ] [ then ] 12 kod ] [ else 14 kod ] 15 end Składnia 1 liczba = 7 2 case liczba 3 when 1,2,3 # Wykonuje : 1 === l i c z b a 2 === l i c z b a 3 === l i c z b a 4 "mały" 5 when 4,5, 6 6 "ś redni " 7 when 7,8, 9 8 "duży" 9 else 10 " olbrzymi " 11 end 12 => duży 13 ########################### 14 a = 2 15 case 16 when a == 1, a == 2 17 "a ma warto ść jeden lub dwa " 18 when a == 3 19 "a ma warto ść trzy " 20 else 21 " Nie potrafi ę okre ślić warto ści zmiennej a" 22 end 23 => a ma wartość jeden lub dwa 24 ########################### 25 case url 26 when / 27 " protok ół HTTP " else 30 " nieznany protok ół" 31 end Przykład użycia Dr inż. Stanisław Polak 30 Przedmiot: Programowanie w języku Ruby Materiały dla studentów Informatyki wydziału IET AGH w Krakowie Struktury kontrolne Struktury kontrolne Pętle while oraz until 1 while warunek [ do ] 2 kod 3 end 4 5 begin 6 kod 7 end while warunek 8 9 kod while warunek Składnia pętli while 1 line=nil 2 while line! /ˆ $/ do line = gets. chomp end 3 ######################## 4 i=1 5 while i < 3 6 puts i 7 i += 1 #W Ruby n i e ma i n s t r u k c j i ++ / 8 j = 2 9 end 10 puts j #Wypisze : 2 11 ######################## 12 i=1 13 begin 14 puts i 15 i += 1 16 j = 2 17 end while i < 3 #Ta k o n s t r u k c j a n i e j e s t z a l e c a n a p r z e z Matz a 18 puts j #Wypisze : 2 19 ######################## 20 line = gets. chomp while line! /ˆ $/ 1 until warunek [ do ] 2 kod 3 end 4 5 until while warunek 6 7 begin 8 kod 9 end until warunek Składnia pętli until 1 line=nil 2 until line = /ˆ $/ do line = gets. chomp end 3 ######################## 4 i=1 5 until i >= 3 do 6 puts i 7 i += 1 8 j = 2 9 end 10 puts j #Wypisze : 2 11 ######################## 12 i=1 13 begin 14 puts i 15 i += 1 16 j = 2 17 end until i >= 3 #Ta k o n s t r u k c j a n i e j e s t z a l e c a n a p r z e z Matz a 18 puts j #Wypisze : 2 19 ######################## 20 line = gets. chomp until line = /ˆ $/ Instrukcje break, redo oraz next 1 i = 0 2 while p " Wyra ż enie while " 3 i += 1 4 printf "\ti =%d\n", i 5 case i 6 when 2 7 puts "\ twykonuj ę next " 8 next 9 when 4 10 puts "\ twykonuj ę redo " 11 redo 12 when 6 13 puts "\ twykonuj ę break " 14 break 15 end 16 puts "\ tjestem na końcu while " 17 end 18 puts Koniec Na wyjściu Wyrażenie while i=1 Jestem na końcu while Wyrażenie while i=2 Wykonuję next Wyrażenie while i=3 Jestem na końcu while Wyrażenie while i=4 Wykonuję redo i=5 Jestem na końcu while Wyrażenie while i=6 Wykonuję break Koniec Dr inż. Stanisław Polak 31 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 32 Przedmiot: Programowanie w języku Ruby

9 Struktury kontrolne Struktury kontrolne Pętla loop Pętla for oraz metody iteracyjne 1 #Petla niesko ńczona 2 loop do 3 puts " Witaj " 4 end 5 6 #P e t l a sko ń czona 7 i = 1 8 loop do 9 puts i 10 i += 1 11 j = 2 12 break if i > 3 13 end 14 puts j #u n d e f i n e d l o c a l v a r i a b l e o r method j 1 for i in do 2 puts i 3 end 4 # Powyż szy kod j e s t r ównoważny : 5 # ( ). each{ i p u t s i } 6 ############## 7 strs = [ " abc \n", " cdae \n", " zzas \n", " aaaa \n" ] 8 strs. each{ s s. chop! } 9 p strs 10 ############## times { i puts i } 12 ############## upto (4) { i puts i } 14 ############## downto (2) { i puts i } 16 ############## step (1 0, 2) { i puts i } 18 ############## step ( 1 0, 2) do i 20 puts i 21 redo 22 end Dr inż. Stanisław Polak 33 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 34 Przedmiot: Programowanie w języku Ruby Typy danych Typy podstawowe Typy danych Rodzaje typów danych Typy podstawowe Podstawowe Wbudowane Pozostałe Liczby Wyrażenia regularne Przedziały Tablice Hasze Łańcuchy znaków Symbole Wartości logiczne Typ pusty Klasy i moduły Dr inż. Stanisław Polak 35 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 36 Przedmiot: Programowanie w języku Ruby

10 Typy podstawowe Typy danych Typy liczbowe Fixnum Typy podstawowe Typy danych Wyrażenia regularne => hour #Dost ę pne w RoR l u b po wykonaniu r e q u i r e a c t i v e s u p p o r t / a l l 4 => 3600 Bignum Float Rational 1 Rational ( 1, 3 ) + Rational ( 1, 2 ) # = => ( 5 / 6 ) r #Skł adnia dost ępna począwszy od w e r s j i => (1/10) r 3 6 => (3/10) Complex 1 Complex ( 1, 2 )+Complex ( 2, 3 ) # <=> (1+2 i ) +(2+3 i )=(3+5 i ) 2 => (3+5i ) 3 42 ri #Skł adnia dost ępna począwszy od w e r s j i => (0+(42/1) i ) Konwersje 1 Integer ( ) 2 => 10 3 Integer (0 b ) #k o n w e r s j a z kodu b i n a r n e g o 4 => Integer (01231) #k o n w e r s j a z kodu ó semkowego 6 => Integer (0 xaabb ) #k o n w e r s j a z kodu s z e s n a s t k o w e g o 8 => Float ( 1 0 ) 10 => Integer ( " aaa " ) 12 ArgumentError : invalid value for Integer ( ) : " aaa " 13 Float ( " aaa " ) 14 ArgumentError : invalid value for Float ( ) : " aaa " 1 name = " Matz " 2 name = / ( [ [ : lower : ] ] { 2 } ) / 3 $ 4 => "M" 5 $1 6 => "at" 7 $ 8 => "z" 9 #I n n e sposoby k o n s t r u k c j i wyra ż e n i a r e g u l a r n e g o 10 name = %r ( [ [ : lower : ] ] { 2 } ) 11 => 1 12 re = Regexp.new( " ([[: lower :]]{2}) " ) 13 md = re. match( name ) 14 => #<MatchData : 0 xb7d41054> 15 md. pre match 16 => "M" 17 md. value at 1 18 => "at" 19 md. post match 20 => "z" Dr inż. Stanisław Polak 37 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 38 Przedmiot: Programowanie w języku Ruby Typy podstawowe Typy danych Przedziały # Z a k r e s od 1 do # Z a k r e s od 1 do ( ). to_a # => [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 1 0 ] 5 ( ). to_a # => [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ] 6 7 ( a.. l ). to_a # => [ a, b, c, d, e, f, g, h, i, j, k, l ] 8 ( Z.. a ). to_a # => [ Z, [, \\, ], ˆ,,, a ] 9 10 ( cab.. car ). to_a # => [ cab, cac, cad, cae, c a f, cag, cah, c a i, c a j, cak, c a l, cam, can, cao, cap, caq, c a r ] Dr inż. Stanisław Polak 39 Przedmiot: Programowanie w języku Ruby Typy podstawowe Typy danych Przedziały Metody 1 words = cab.. car 2 words. min 3 => " cab " 4 words. max 5 => " car " 6 words. include?( can ) 7 => true 8 words ===( can ) 9 => true 10 words. reject { subrange subrange < cal } 11 => [ " cal ", " cam ", " can ", " cao ", " cap ", " caq ", " car " ] 12 words. each { word puts " Hello " + word} 13 Hello cab 14 Hello cac Hello car Dr inż. Stanisław Polak 40 Przedmiot: Programowanie w języku Ruby ateriały dla studentów Informatyki wydziału IET AGH w Krakowie

11 Typy podstawowe Typy danych Przedziały Przykłady zastosowania 1 while input = gets 2 puts input + " triggered " if input = / start /.. input = / end / 3 end Na wyjściu 1 2 start start triggered 1 1 triggered 2 2 triggered end end triggered score = 70 2 result = 3 case score 4 when : " Nie zaliczy ł ( obla ł test )" 5 when : " Zaliczy ł" 6 when : " Zaliczy ł z wysokim wynikiem " 7 when : " Zaliczy ł z wyr óż nieniem " 8 else " Nieprawid ł owy wynik testu " 9 end 10 puts result Typy podstawowe Typy danych Tablice zwykłe 1 days_of_week = Array. new ( 7 ) 2 => [ nil, nil, nil, nil, nil, nil, nil ] 3 days_of_week = Array. new (7, " today " ) 4 => [ " today ", " today ", " today ", " today ", " today ", " today ", " today " ] 5 days_of_week = Array[ " Mon ", " Tues ", " Wed ", " Thu ", " Fri ", " Sat ", " Sun " ] 6 #l u b 7 days_of_week = [ " Mon ", " Tues ", " Wed ", " Thu ", " Fri ", " Sat ", " Sun " ] 8 => [ " Mon ", " Tues ", " Wed ", " Thu ", " Fri ", " Sat ", " Sun " ] 9 days_of_week. empty? 10 => false 11 days_of_week. size 12 => 7 13 days_of_week. length 14 => 7 15 days_of_week[0] 16 => " Mon " 17 days_of_week. at(0) 18 => " Mon " 19 days_of_week. first 20 => " Mon " 21 days_of_week [ 0 ]. class 22 => String 23 days_of_week. index( "Wed " ) 24 => 2 25 days_of_week[1, 3] 26 => [ " Tues ", " Wed ", " Thu " ] 27 days_of_week[1..3] 28 => [ " Tues ", " Wed ", " Thu " ] Dr inż. Stanisław Polak 41 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 42 Przedmiot: Programowanie w języku Ruby Typy podstawowe Typy danych Tablice zwykłe c.d. Typy podstawowe Typy danych Tablice asocjacyjne 1 matrix = [ [ 1, 2, 3 ], [ 3, 4, 5 ], [ 5, 6, 7 ] ] 2 matrix [ 1 ] 3 => [ 3, 4, 5 ] 4 matrix[1][1] 5 => 4 6 matrix [ 1, 1 ] 7 => [ [ 3, 4, 5 ] ] 8 ############################################ 9 operating_systems = [ " Fedora ", "SuSE ", "RHEL ", " Windows ", " MacOS " ] 10 linux_systems = [ "RHEL ", "SuSE ", " PCLinuxOS ", " Ubuntu ", " Fedora " ] 11 operating_systems linux_systems 12 => [ " Fedora ", " SuSE ", " RHEL ", " Windows ", " MacOS ", " PCLinuxOS ", " Ubuntu " ] 13 operating_systems & linux_systems 14 => [ " Fedora ", " SuSE ", " RHEL " ] 15 operating_systems - linux_systems 16 => [ " Windows ", " MacOS " ] 17 days1 = [ " Mon ", " Tue ", " Wed " ] 18 days2 = [ " Thu ", " Fri ", " Sat ", " Sun " ] 19 days = days1 + days2 20 days 21 => [ " Mon ", " Tue ", " Wed ", " Thu ", " Fri ", " Sat ", " Sun " ] 22 days1 23 => [ " Mon ", " Tue ", " Wed " ] 24 ############################################ 25 days1 = [ " Mon ", " Tue ", " Wed " ] 26 days2 = [ " Thu ", " Fri ", " Sat ", " Sun " ] 27 days = days1. concat( days2 ) 28 => [ " Mon ", " Tue ", " Wed ", " Thu ", " Fri ", " Sat ", " Sun " ] 29 days 30 => [ " Mon ", " Tue ", " Wed ", " Thu ", " Fri ", " Sat ", " Sun " ] 31 days1 32 => [ " Mon ", " Tue ", " Wed ", " Thu ", " Fri ", " Sat ", " Sun " ] ############################################ 35 days1 = [ " Mon ", " Tue ", " Wed " ] 36 days2 = [ " Thu ", " Fri ", " Sat ", " Sun " ] 37 days = days1 << days2 38 days 39 => [ " Mon ", " Tue ", " Wed ", [ " Thu ", " Fri ", " Sat ", " Sun " ] ] 40 days1 41 => [ " Mon ", " Tue ", " Wed ", [ " Thu ", " Fri ", " Sat ", " Sun " ] ] 1 hash = { " jeden " => 1, "dwa " => 2, "trzy " => 3 } 2 hash[ jeden ] 3 => 1 4 hash1 = {jeden : 1, dwa : 2, trzy :3} #Sk ł a d n i a d o s t ę pna pocz ą wszy od w e r s j i => {: jeden=>1, : dwa=>2, : trzy=>3} 6 hash1 [ : jeden ] 7 => 1 8 histogram = Hash. new(0) 9 => {} 10 histogram [ "Ala " ] 11 => 0 12 histogram [ "Ala " ] += 1 13 => 1 14 histogram [ "Ala " ] 15 => 1 16 hash. has key?( " jeden " ) 17 => true 18 hash. has value?( " jeden " ) 19 => false Dr inż. Stanisław Polak 43 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 44 Przedmiot: Programowanie w języku Ruby

12 Typy podstawowe Typy danych Uporządkowane tablice asocjacyjne 1 h = {"c" => 3, "a" => 1, "b" => 2} 2 h. each do k, v 3 p [ k, v ] 4 end 5 6 #Wynik d z i a ł a nia : 7 # Ruby 1.9+ Ruby [ "c", 3 ] [ "a", 1 ] 9 [ "a", 1 ] [ "b", 2 ] 10 [ "b", 2 ] [ "c", 3 ] 1 h = {} 2 h [ "a" ] = " foo " 3 h [ "b" ] = " bar " 4 p h 5 # Na wyj ś c i u : 6 {"a"=>" foo ", "b"=>" bar "} 7 8 h [ "a" ] = nil 9 p h 10 #Na wyj ś c i u : 11 {"a"=>nil, "b"=>" bar "} h. delete ( "a" ) 14 h [ "a" ] = " foo " 15 p h 16 #Na wyj ś c i u : 17 {"b"=>" bar ", "a"=>" foo "} Typy podstawowe Typy danych Łańcuchy znaków Tworzenie i formatowanie 1 ####### t w o r z e n i e ł ań cucha ####### 2 mystring = String.new 3 => "" 4 mystring = String.new( " This is my string. Get your own string " ) 5 mystring = String( "This is also my string " ) # metoda String j e s t metodą modułu K e r n e l k o n w e r s j a do typu napisowego 6 mystring = This is also my string 7 mystring = This is also my string 8 ####### w y p i s a n i e ł ań cucha ####### 9 #{mystring} #{1+3} l u b %Q&#{myString} #{1+3} & l u b %&#{mystring} #{1+3}& l u b %[#{ mystring} #{1+3}] 10 => " This is also my string 4" 11 #{mystring} l u b %q&#{mystring}& l u b %q(#{ mystring}) 12 => " \#{ mystring }" 13 ls lub %x&ls& lub %x{ls} 14 => Wynik wykonania komendy ls 15 ####### sk ł a d n i a HereDocs ####### 16 mytext= «DOC #{mystring} 19 DOC 20 DOC 21 => "1\ nthis is also my string \n DOC \n" 22 mytext= «-DOC #{mystring} 25 DOC 26 => "1\ nthis is also my string \n" 27 ####### Tworzenie t a b l i c y n a p i s ów ####### 28 %w(1 2 aaa ) 29 => [ "1", "2", " aaa " ] 30 ####### Formatowanie ł ań cucha ####### 31 a=1 32 b=2 33 "a=%d" % a 34 => "a=1" 35 "a=%d, b=%d" % [ a, b ] 36 => "a=1, b=2" 37 "c =%{ c}, d =%{ d}" % {: c=>3,:d=>4} 38 => "c=3,d=4" 39 ############### Wybrane metody ############### 40 mystring = " Hello " 41 mystring. length 42 => 5 43 mystring. size 44 => 5 45 mystring. empty? 46 => false 47 mystring. sub( H, h ) 48 => " hello " 49 mystring 50 => " Hello " 51 mystring. sub!( H, h ) 52 => " hello " 53 mystring 54 => " hello " 55 mystring. object_id 56 => mystring. sub! ( h, H ) 58 => " Hello " 59 mystring. object_id 60 => Dr inż. Stanisław Polak 45 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 46 Przedmiot: Programowanie w języku Ruby Typy podstawowe Typy danych Łańcuchy znaków Łączenie, dostęp do fragmentów oraz porównywanie 1 ############### ł ą c z e n i e ############### 2 mystring = " Welcome " + "to " + " Ruby!" #konkatenacja ( nie modyfikuje ł ańcucha z l e w e j ) 3 => " Welcome to Ruby!" 4 mystring = " Welcome " "to " " Ruby!" #jw. 5 => " Welcome to Ruby!" 6 mystring = "Welcome ". concat( "to " ). concat( "Ruby!" ) #do ł ącza do ł ańcucha z lewej ( m o d y f i k u j e go ) 7 => " Welcome to Ruby!" 8 mystring = " Welcome " «"to " «" Ruby!" #jw. 9 => " Welcome to Ruby!" 10 ############### d o s t ę p do fragment ów ############### 11 mystring[ Ruby ] 12 => " Ruby " 13 mystring[ Perl ] 14 => nil 15 mystring[3] #Ruby => "c" 17 mystring[3].ord #Ruby => mystring[3].chr #Ruby => "c" 21 mystring[11, 4] 22 => " Ruby " 23 mystring[0..6] 24 => " Welcome " 25 mystring[/[a-z]/] 26 => "W" 27 mystring. index( Ruby ) 28 => ############### por ó wnywanie ############### 30 " John " == " Fred " # John. eql? Fred 31 => false 32 " Apples " <=> " Apples " # Apples.casecmp apples 33 => 0 Typy podstawowe Typy danych Łańcuchy znaków Zastępowanie, substytucja, wstawianie 1 ####### podmiana ####### 2 mystring = " Welcome to JavaScript!" 3 mystring[" JavaScript "]= " Ruby " 4 puts mystring 5 => " Welcome to Ruby!" 6 mystring = " Welcome to JavaScript!" 7 mystring [ 10 ] = " Ruby " 8 puts mystring 9 => " Welcome torubyjavascript!" 10 mystring = " Welcome to JavaScript!" 11 mystring [ ] = " Ruby " 12 puts mystring 13 => " Welcome Ruby!" 14 ####### s u b s t y t u c j a ####### 15 mystring = " Welcome to PHP " 16 mystring. gsub( " PHP ", " Ruby " ) 17 => " Welcome to Ruby " 18 mystring. replace( "Goodbye to PHP!" ) 19 => " Goodbye to PHP!" 20 ####### p o w i e l a n i e ####### 21 mystring * 3 22 => " Goodbye to PHP! Goodbye to PHP! Goodbye to PHP!" 23 ####### w s t a w i a n i e ####### 24 mystring1 = " Paris in Spring " 25 mystring2 = " Paris in Spring " 26 mystring1 [8]= " the " # podmiana, a nie wstawienie przed 27 => " the " 28 mystring1 29 => " Paris in thespring " 30 mystring2. insert (8, " the " ) 31 => " Paris in the Spring " 32 mystring2 33 => " Paris in the Spring " Dr inż. Stanisław Polak 47 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 48 Przedmiot: Programowanie w języku Ruby

13 Typy podstawowe Typy danych Łańcuchy znaków Konwersja 1 myarray = Array( " ABCDEFGHIJKLMNOP " ) 2 => [ " ABCDEFGHIJKLMNOP " ] 3 myarray = " ABCDEFGHIJKLMNOP ". split 4 => [ " ABCDEFGHIJKLMNOP " ] 5 myarray = " ABCDEFGHIJKLMNOP ". split(//) 6 => [ "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", " P" ] 7 " 1000 ". to i 8 => "aaa ". to i #Nie wyrzuca wyją tku 10 => 0 Dr inż. Stanisław Polak 49 Przedmiot: Programowanie w języku Ruby Typy podstawowe Typy danych Symbole Typy podstawowe Typy danych Łańcuchy znaków Obsługa polskich znaków 1 # encoding : utf 8 2 # coding : UTF 8 3 # coding : UTF 8 4 # vim : s e t f i l e e n c o d i n g=utf 8: 5 ################################################################################ 6 #W przypadku Ruby 2. 0 powyż sze l i n i e nie s ą potrzebne, gdy ż domyś lnym kodowaniem j e s t UTF 8 7 ############################################################################### 8 9 s="ąćę" 10 puts s. size 11 puts s. bytesize 12 puts s [ 2 ] 13 puts s [ 1, 3 ] Wynik dla Ruby ę ćę Wynik dla Ruby ?ć Dr inż. Stanisław Polak 50 Przedmiot: Programowanie w języku Ruby Materiały dla studentów Informatyki wydziału IET AGH w Krakowie Typy podstawowe Typy danych Typ logiczny oraz pusty 1 #Tworzenie s y m b o l i 2 s1 = :Polak 3 s2 = : Polak 4 %s( Stanis ł aw Polak ) 5 => : " Stanis ław Polak " 6 #Tworzenie t a b l i c y s y m b o l i 7 %i( Stanis ł aw Polak ) #Dost ę pne w Ruby => [ : Stanis ł aw, : Polak ] 9 ################## 10 str1 = " Stanis ław" 11 str2 = " Stanis ław" 12 s1. object id == s2. object id 13 => true 14 str1. object id == str2. object id 15 => false 16 ############################### 17 "Stanis ław" << " Polak " 18 => " Stanis ław Polak " 19 :Śtanisław«: Polak 20 NoMethodError : undefined method << for : Stanis ław: Symbol 21 ############################### 22 :" Stanis ław Polak ".to s 23 => " Stanis ław Polak " 24 " Stanis ław Polak ".to sym 25 => :" Stanis ław Polak " 26 ############################### 27 :" Stanis ław Polak ".length # :" Stanis ław Polak ". to_s. length 28 = >15 29 : Polak.gsub( P, p ) 30 NoMethodError : undefined method gsub for : Polak : Symbol 1 key = " Jab łko" 2 => " Jab łko" 3 histogram [ key ] = 10 4 => 10 5 histogram [ key ] 6 => 10 7 key. sub! ( "o", "a" ) 8 => " Jab łka" 9 key 10 => " Jab łka" 11 histogram [ key ] 12 => nil 13 histogram [ "Jab łko" ] 14 => ########################## 16 key=: Jab ł ko 17 => : Jab ł ko 18 histogram [ key ] = => key. sub! ( "o", "a" ) 21 NoMethodError : undefined method sub! for : Jabł ko: Symbol histogram [ key ] 23 => 10 1 a = "" 2 a. nil? 3 => false 4 a = [ ] 5 a. nil? 6 => false 7 a = 0 8 a. nil? 9 => false 10 a = nil 11 a. nil? 12 => true 13 if 0 and [] and 14 " True " 15 else 16 " False " 17 end 18 => " True " 19 if false or nil 20 " True " 21 else 22 " False " 23 end # => F a l s e Dr inż. Stanisław Polak 51 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 52 Przedmiot: Programowanie w języku Ruby

14 Typy podstawowe Typy danych Porównywanie wartości Funkcje Podprogramy Funkcje 1 #Przyk ł ad ze strony http : / / stackoverflow. com/ q u e s t i o n s / / whats the d i f f e r e n c e between equal e q l and 2 def eq ( a, b ) 3 puts " #{[a, ==, b]} : #{a == b}" 4 puts " #{[a,. eql?, b]} : #{a.eql?(b)}" 5 puts " #{[a, ===, b]} : #{a === b}" 6 puts " #{[a,. equal?, b]} : #{a.equal?(b)}" 7 end 8 9 eq ( Object. new, Object. new ) 10 eq ( " all ", " all " ) 11 eq ( : all, : all ) 12 eq ( 3, 3) 13 eq ( 1, 1. 0 ) Na wyjściu [#<Object:0x e11c0>, "==", #<Object:0x e1198>] : false [#<Object:0x e11c0>, ".eql?", #<Object:0x e1198>] : false [#<Object:0x e11c0>, "===", #<Object:0x e1198>] : false [#<Object:0x e11c0>, ".equal?", #<Object:0x e1198>] : false ["all", "==", "all"] : true ["all", ".eql?", "all"] : true ["all", "===", "all"] : true ["all", ".equal?", "all"] : false [:all, "==", :all] : true [:all, ".eql?", :all] : true [:all, "===", :all] : true [:all, ".equal?", :all] : true [3, "==", 3] : true [3, ".eql?", 3] : true [3, "===", 3] : true [3, ".equal?", 3] : true [1, "==", 1.0] : true [1, ".eql?", 1.0] : false [1, "===", 1.0] : true [1, ".equal?", 1.0] : false 1 #################### 2 #D e f i n i o w a n i e f u n k c j i 3 #################### 4 def nazwa funkcji(par1, par2=wartość domyślna,... ) return warto ś ć 7 end 8 ############################### 9 def good_bye (*guys) 10 "Do widzenia " + guys. join ( " i " ) 11 end ################### 14 #Wywoł ywanie f u n k c j i 15 ################### nazwa funkcji(arg1,arg2,... ) 18 ############################### 19 good_bye ( " Stanisławie ", " Marcinie " ) 20 => "Do widzenia Stanis ł awie i Marcinie " 1 def funkcja ( a=1,b:2,c:3) 2 puts a 3 puts b 4 puts c 5 end 6 7 funkcja ( 1 ) #Wypisze : w osobnych l i n i a c h 8 funkcja ( 1, 1 ) #... wrong number o f arguments (2 f o r ) ( ArgumentError ) 9 funkcja ( c : 2 0, b : 1 0 ) #Wypisze : w osobnych l i n i a c h 10 argumenty = { c : 2 0 0, b : } 11 funkcja ( 3, **argumenty ) #Wypisze : w osobnych l i n i a c h 12 def moja_funkcja ((a, b)) 13 p a : a, b : b 14 end 15 moja_funkcja ( [ 1, 2 ] ) #Wypisze : {: a=>1, : b =>2} Dr inż. Stanisław Polak 53 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 54 Przedmiot: Programowanie w języku Ruby Funkcje Podprogramy Przeciążanie operatorów Bloki Podprogramy Charakterystyka bloku 1 class Liczba 2 def initialize ( a ) = a 4 end 5 6 def +(b ) + b 8 end puts " zanegowa łeś liczb ę" 12 end 13 end 14 liczba = Liczba. new ( 1 ) 15 puts liczba+4 16 liczba Fragmenty kodu, które mogą być przypisywane do zmiennych i przekazywane jako parametry wywołań funkcji Tworzą tzw. domknięcie nad zmiennymi Postacie bloku {} do... end Na wyjściu 5 zanegowałeś liczbę Dr inż. Stanisław Polak 55 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 56 Przedmiot: Programowanie w języku Ruby

15 Bloki Podprogramy Przykłady Bloki Podprogramy Przykłady 1 #d e f i n i o w a n i e b l o k ów 2 { x, y, z x + y + z } 3 do x, y, z 4 x + y + z 5 end 6 #przekazywanie bloku jako parametru wywo ł a nia metody 7 a = [ 1, 2, 3 ]. reject{ e e % 2 == 1} 8 #p r z e k s z t a ł c e n i e w o b i e k t 9 odd = lambda { e e % 2!= 0} 10 odd = >(e ){e % 2!=0} #Sk ł a d n i a d o s t ę pna pocz ą wszy od w e r s j i ( ) moż na pomin ą ć 11 even_numbers = [ 1, 2, 3 ]. reject &odd 12 odd_number = [ 1, 2, 3 ]. select &odd 13 odd. call ( 3 ) 14 => true 15 odd[3] # metoda [ ] a l i a s metody c a l l ( ) 16 => true 17 odd.(3) #Sk ł adnia dost ępna pocz ąwszy od w e r s j i => true 1 def dwarazy 2 yield 3 yield 4 end 5 dwarazy { puts " Witaj " } #można również wywoł ać tak : dwarazy ( ) { puts Witaj } 6 #Na wyj ś c i u : 7 Witaj 8 Witaj 9 10 def dwarazy 11 yield 1 12 yield 2 13 end 14 dwarazy { i puts "#{i}. raz : Witaj "} 15 #Na wyj ś c i u : raz : Witaj raz : Witaj def dwarazy (&block) 20 block. call 1 21 block. call 2 22 end 23 dwarazy { i puts "#{i}. raz : Witaj "} 24 #Na wyj ś ciu raz : Witaj raz : Witaj 27 =begin 28 Mo ż na ró wnie ż wywo ł a ć tak : 29 dwarazy ( ) { i puts "#{i}. raz : Witaj "} 30 ale nie tak : 31 dwarazy ( { i puts "#{i}. raz : Witaj "} ) 32 =end Dr inż. Stanisław Polak 57 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 58 Przedmiot: Programowanie w języku Ruby Bloki Podprogramy Argumenty bloków 1 i = " foo " 2 j = " foo " 3 puts " Przed blokiem : i = #{i}" 4 puts " Przed blokiem : j = #{j}" 5 3. times do i 6 puts "i = #{i}" 7 j = i 8 k = 2 9 end 10 puts " Poza blokiem : i = #{i}" 11 puts " Poza blokiem : j = #{j}" 12 puts " Poza blokiem : k = #{k}" Wynik dla Ruby 1.9 Przed blokiem: i = foo Przed blokiem: j = foo i = 0 i = 1 i = 2 Poza blokiem: i = foo Poza blokiem: j = 2 <main> : undefined local variable or method k for main:object (NameError) Wynik dla Ruby 1.8 Przed blokiem: i = foo Przed blokiem: j = foo i = 0 i = 1 i = 2 Poza blokiem: i = 2 Poza blokiem: j = 2 undefined local variable or method k for main:object (NameError) Dr inż. Stanisław Polak 59 Przedmiot: Programowanie w języku Ruby Bloki Podprogramy Zmienne lokalne dla bloków 1 j = 2 2 jj = 2 3 a = lambda { ;jj j = 1 ; jj = 1} #Sk ł adnia dost ępna pocz ąwszy od w e r s j i a. call ( ) 5 puts j # 1 6 puts jj # 2 Dr inż. Stanisław Polak 60 Przedmiot: Programowanie w języku Ruby ateriały dla studentów Informatyki wydziału IET AGH w Krakowie

16 Bloki Podprogramy Obiekt Proc Bloki Podprogramy Domknięcia 1 # Obiekt Proc 2 p = Proc. new { puts " Hello World " } 3 p = proc {puts " Hello World "} #To samo co wyż e j 4 # proc <=> lambda, dla Ruby < # proc <=> Proc. new, dla Ruby >= p. call # wypisze He ll o World 7 p. class # zwr ó c i Proc 8 # B l o k i 9 { puts " Hello World "} #Bł ąd sk ł adniowy 10 a = { puts " Hello World "} #Bł ąd sk ł adniowy 11 [ 1, 2, 3 ]. each { x puts x/2} #OK 12 ################################## 13 def metoda ( proc1, proc2 ) 14 proc1. call 15 proc2. call 16 end 17 a = Proc. new { puts " Pierwszy proc "} 18 b = Proc. new { puts " Drugi proc "} 19 metoda ( a, b ) #OK 20 metoda{puts " Pierwszy proc " }{puts " Drugi proc "} #Bł ąd sk ł adniowy 1 p = proc { x puts x} 2 l = lambda { x puts x} 3 puts p #<Proc : 0 x bca0d8@a. rb :1> 4 puts l ##<Proc : 0 x bca0b0@a. rb : 2 ( lambda )> 5 p. call #Zwraca n i l 6 l. call #ArgumentError : wrong number of arguments (0 f o r 1) 7 p. call ( 1, 2 ) #Wypisze : 1, p o z o s t a ł e argumenty s ą ignorowane 8 l. call ( 1, 2 ) #ArgumentError : wrong number of arguments (2 f o r 1) 9 ################################## 10 def metoda_lambda 11 l = lambda { return } # return wyskakujemy z lambda 12 l. call 13 puts " Hello world " 14 end def metoda_proc 17 p = proc { return } # return wyskakujemy z metoda proc 18 p. call 19 puts " Hello world " 20 end metoda_lambda #Wypisze : H e l l o World 23 metoda_proc #Nic n i e w y p i s z e 1 =begin 2 funkcja wykorzystuje trzy zmienne : 3 y dost ępn ą dla u ż ytkownika 4 x dostępną tylko wewnątrz funkcji mnozenie_przez () 5 z dostępną tylko wewnątrz funkcji mnozenie_przez () 6 =end 7 ############################################################ 8 def mnozenie_przez ( x ) 9 z=0 10 lambda { y z+= 1 ; printf "z=%d, %d*%d=", z, x, y ; return x y} 11 end 12 ############################################################ 13 iloczyn_5_przez = mnozenie_przez ( 5 ) # Parametrowi x j e s t przypisywana warto ś ć 5 14 iloczyn_6_przez = mnozenie_przez ( 6 ) # Parametrowi x j e s t przypisywana warto ś ć 6 15 ############################################################ 16 puts iloczyn_5_przez #Wypisze : #<Proc : 0 x c0de38@lambda. rb : 8 ( lambda )> 17 x=10 18 y=20 19 z=30 20 puts iloczyn_5_przez. call ( 1 0 ) # Wypisze : z =1, 5 10=50 21 puts iloczyn_5_przez. call ( 1 1 ) # Wypisze : z =2, 5 11=55 22 puts iloczyn_6_przez. call ( 1 2 ) # Wypisze : z =1, 6 12=72 23 ############################################################ 24 puts x #Wypisze : puts y #Wypisze : puts z #Wypisze : 20 1 Fragment kodu, w którym zmienne lokalne zachowują swoją tożsamość Dr inż. Stanisław Polak 61 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 62 Przedmiot: Programowanie w języku Ruby Programowanie funkcjonalne Zasady Programowanie funkcjonalne Programowanie imperatywne a programowanie funkcjonalne Programowanie imperatywne Skupia się na jak Programy zawierają listę instrukcji, które mówią komputerowi, co zrobić z danymi wejściowymi Programowanie funkcjonalne Skupia się na co Rozkłada problem w zestaw funkcji Functional programming is like describing your problem to a mathematician. Imperative programming is like giving instructions to an idiot (arcus, #scheme on Freenode) 1 n, num_elements, sum = 1, 0, 0 2 while num_elements < 10 3 if n 2 % 5 == 0 4 sum += n 5 num_elements += 1 6 end 7 n += 1 8 end 9 sum 10 => 275 Podejście imperatywne 1 ( 1.. Float : : INFINITY ). lazy. select { x x 2 % 5 == 0 }. take (10). inject (:+) 2 => 275 Podejście funkcjonalne Nie modyfikuj zmiennych Nie 1 indeksy = [ 1, 2, 3 ] 2 indeksy << 4 3 ######################## 4 hasz = {: a => 1, : b => 2} 5 hasz [ : c ] = 3 6 ######################## 7 napis = " witaj " 8 napis. gsub! ( / t /, l ) Tak 1 indeksy = [ 1, 2, 3 ] 2 wszystkie_indeksy = indeksy + [ 4 ] 3 ######################## 4 hasz = {: a => 1, : b => 2} 5 nowy_hasz = hasz. merge ( : c => 3) 6 ######################## 7 napis = " witaj " 8 nowy_napis = napis. gsub (/ t /, l ) Dr inż. Stanisław Polak 63 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 64 Przedmiot: Programowanie w języku Ruby

17 Zasady Programowanie funkcjonalne Bloki jako funkcje wyższego rzędu 1 open ( "/etc / passwd " ) { plik puts plik. size} Funkcja, która zawiera funkcję na liście argumentów 1 def dodawacz ( a ) 2 proc { b a + b} 3 end 4 dodawacz5 = dodawacz ( 5 ) 5 puts dodawacz5. call ( 3 ) #Wypisze : 8 Funkcja, która zwraca funkcję Dr inż. Stanisław Polak 65 Przedmiot: Programowanie w języku Ruby Zasady Programowanie funkcjonalne Częściowe zastosowanie funkcji oraz rozwijanie funkcji 1 f = proc { x, y, z [ x, y, z ] } 2 p f [ 4, 5, 6 ] # [ 4, 5, 6 ] 3 p f [ 4, 5, 6 ] # [ 4, 5, 6 ] 4 p f [ 4 ] [ 5, 6 ] # n i l 5 p f [ 4, 5 ] [ 6 ] # n i l 6 p f [ 4 ] [ 5 ] [ 6 ] # u n d e f i n e d method [ ] 1 suma = proc { x, y, z x + y + z } f o r n i l : N i l C l a s s ( NoMethodError ) 2 p suma. call ( 1, 2, 3) # p suma [ 1, 2, 3 ] # 6 8 g = f. curry 4 9 p g [ 4, 5, 6 ] # [ 4, 5, 6 ] 5 # Cz ę ś ciowe z a s t o s o w a n i e f u n k c j i ( ang. 10 p g [ 4 ] [ 5, 6 ] # [ 4, 5, 6 ] p a r t i a l f u n c t i o n a p p l i c a t i o n ) 11 p g [ 4, 5 ] [ 6 ] # [ 4, 5, 6 ] 6 suma_partial = proc { x, y proc { z 12 p g [ 4 ] [ 5 ] [ 6 ] # [ 4, 5, 6 ] x + y + z } } 13 7 p suma_partial. call ( 1, 2). call ( 3 ) # 6 14 h = g [ 1 ] # x o t r z y m u j e warto ś ć 1 8 p suma_partial [ 1, 2 ] [ 3 ] # [ 1, 2, 3 ] 15 p h [ 4, 5, 6 ] # [ 1, 4, 5 ] 9 16 p h [ 4, 5 ] # [ 1, 4, 5 ] 10 # R o z w i j a n i e f u n k c j i ( ang. c u r r y i n g ) 17 p h [ 4 ] [ 5 ] # [ 1, 4, 5 ] 11 suma_curry= proc { x proc { y proc { 18 p h [ 4 ] # #<Proc : 0 x c0 z x + y + z } } } > 12 p suma_curry. call ( 1 ). call ( 2 ). call ( 3 ) # p suma_curry [ 1 ] [ 2 ] [ 3 ] # 6 20 i = h [ 2 ] # y o t r z y m u j e warto ś ć 2 21 p i [ 4, 5, 6 ] # [ 1, 2, 4 ] 22 p i [ 4, 5 ] # [ 1, 2, 4 ] 23 p i [ 4 ] # [ 1, 2, 4 ] j = i [ 3 ] # z o t r z y m u j e warto ś ć 3 26 p j # [ 1, 2, 3 ] Zalety Łatwiejsze testowanie kodu Kod jest bardziej zwięzły Kod jest w większym stopniu reużywalny Dr inż. Stanisław Polak 66 Przedmiot: Programowanie w języku Ruby Zasady Programowanie funkcjonalne Rozwijanie funkcji Przykład użycia Zasady Programowanie funkcjonalne Unikanie skutków ubocznych 1 ################################### 2 # Normal d e f i n i t i o n s 3 # pattern : f (n) dla n [a... b] 4 ################################### 5 sum_ints = lambda do a, b 6 s = 0 ; a. upto ( b ) { n s += n } ; s 7 end 8 9 sum_of_squares = lambda do a, b 10 s = 0 ; a. upto ( b ) { n s += n 2 } ; s 11 end sum_of_powers_of_2 = lambda do a, b 14 s = 0 ; a. upto ( b ) { n s += 2 n } ; s 15 end puts sum_ints. ( 1,5) #=> puts sum_of_squares. ( 1,5) #=> puts sum_of_powers_of_2. ( 1,5) #=> ############################################ 21 # Some r e f a c t o r i n g to make some a b s t r a c t i o n 22 # P a s s i n g t h e sum mechanism i t s e l f 23 ############################################ 24 sum = lambda do f, a, b 25 s = 0 ; a. upto ( b ) { n s += f. ( n ) } ; s 26 end 27 puts sum [ lambda{ x x },1,5] #=> puts sum [ lambda{ x x 2},1,5] #=> puts sum [ lambda{ x 2 x },1,5] #=> ################################### 31 # More r e f a c t o r i n g u s i n g c u r r y i n g 32 ################################### # g e n e r a t e t h e c u r r y i n g 35 currying = sum. curry # G e n e r a t e t h e p a r t i a l f u n c t i o n s 38 sum_ints = currying [ lambda{ x x }] 39 sum_of_squares = currying [ lambda{ x x 2}] 40 sum_of_powers_of_2 = currying [ lambda{ x 2 x }] puts sum_ints [ 1, 5 ] #=> puts sum_of_squares [ 1, 5 ] #=> puts sum_of_powers_of_2 [ 1, 5 ] #=> 62 Nie 1 [ 1, 2, 3 ]. each do x 2 #kod z e f e k t a m i ubocznymi 3 end 4 for i in [ 1, 2, 3 ] do 5 #kod z e f e k t a m i ubocznymi 6 end Źródło: Dr inż. Stanisław Polak 67 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 68 Przedmiot: Programowanie w języku Ruby

18 Funkcje wyższego rzędu Programowanie funkcjonalne Metoda map() Nie 1 wynik = [ ] 2 [ 1, 2, 3, 4 ]. each do x 3 wynik << x 2 4 end 5 wynik #[ 2, 4, 6, 8 ] Tak 1 wynik = [ 1, 2, 3, 4 ]. map do x 2 x 2 3 end #[ 2, 4, 6, 8 ] Dr inż. Stanisław Polak 69 Przedmiot: Programowanie w języku Ruby Funkcje wyższego rzędu Programowanie funkcjonalne Metoda detect() Funkcje wyższego rzędu Programowanie funkcjonalne Metoda select() Nie 1 wynik = [ ] 2 [ 1, 2, 3, 4 ]. each do x 3 wynik << x if x > 2 4 end 5 wynik #[ 3, 4 ] Tak 1 wynik = [ 1, 2, 3, 4 ]. select do x 2 x > 2 3 end #[ 3, 4 ] Dr inż. Stanisław Polak 70 Przedmiot: Programowanie w języku Ruby Materiały dla studentów Informatyki wydziału IET AGH w Krakowie Funkcje wyższego rzędu Programowanie funkcjonalne Metoda inject() Nie 1 wynik = nil 2 [ 1, 2, 3, 4 ]. each do x 3 if x > 2 4 wynik = x 5 break 6 end 7 end 8 wynik #3 Tak 1 wynik = [ 1, 2, 3, 4 ]. detect do x 2 x > 2 3 end #3 Nie 1 suma = 0 2 [ 1, 2, 3, 4 ]. each do x 3 suma += x 4 end 5 suma #10 Tak 1 suma = [ 1, 2, 3, 4 ]. inject ( 0 ) do aku, x 2 aku+x 3 end #10 4 ################################# 5 suma = [ 1, 2, 3, 4 ]. inject ( 0, :+) #10 Dr inż. Stanisław Polak 71 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 72 Przedmiot: Programowanie w języku Ruby

19 Funkcje wyższego rzędu Programowanie funkcjonalne Metoda zip() Funkcje wyższego rzędu Programowanie funkcjonalne Wybrane metody do tworzenia iteratorów Nie 1 a = [ 1, 2, 3, 4 ] 2 b = [ 5, 6, 7, 8 ] 3 wynik =[] 4 0. upto ( a. length 1). each do i 5 wynik << [ a [ i ], b [ i ] ] 6 end 7 wynik #[ [ 1, 5 ], [ 2, 6 ], [ 3, 7 ], [ 4, 8 ] ] Tak 1 a = [ 1, 2, 3, 4 ] 2 b = [ 5, 6, 7, 8 ] 3 wynik = a. zip ( b ) #[ [ 1, 5 ], [ 2, 6 ], [ 3, 7 ], [ 4, 8 ] ] 1 [ 1, 2, 3 ]. permutation ( 2 ). to_a 2 => [ [ 1, 2 ], [ 1, 3 ], [ 2, 1 ], [ 2, 3 ], [ 3, 1 ], [ 3, 2 ] ] 3 [ 1, 2, 3 ]. permutation. to_a 4 => [ [ 1, 2, 3 ], [ 1, 3, 2 ], [ 2, 1, 3 ], [ 2, 3, 1 ], [ 3, 1, 2 ], [ 3, 2, 1 ] ] 5 ############################## 6 [ 1, 2, 3 ]. combination ( 2 ). to_a 7 => [ [ 1, 2 ], [ 1, 3 ], [ 2, 3 ] ] 8 ############################## 9 [ 0, 1, 2, 3 ]. group_by { x x%2} 10 => {0=>[0, 2 ], 1=>[1, 3]} 11 [ 0, 0, 0, 1, 1, 2 ]. group_by { x x }. map { k, v v} 12 => [ [ 0, 0, 0 ], [ 1, 1 ], [ 2 ] ] Dr inż. Stanisław Polak 73 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 74 Przedmiot: Programowanie w języku Ruby Funkcje wyższego rzędu Programowanie funkcjonalne Obiektowość Przykład użycia Obiekty i klasy 1 ( 1.. Float : : INFINITY ). lazy. select { x x 2 % 5 == 0 }. take ( 1 0 ). inject (:+) 2 => 275 Obiekt Klasa wynik ewaluacji wyrażenia posiada stan (atrybuty) nie posiada metod atrybuty dostępne za pomocą metod klasy jest obiektem (instancja klasy Class) posiada metody Dr inż. Stanisław Polak 75 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 76 Przedmiot: Programowanie w języku Ruby

20 Obiektowość Obiektowość Definiowanie klas i tworzenie obiektów Dziedziczenie 1 class Person #K l a s ą bazow ą j e s t O b j e ct 2 def foo 3 puts " person " 4 end 5 end 1 class Player < Person 2 def foo 3 super 4 puts " player " 5 end 6 end 7 p = Player. new 8 p. foo 9 # p e r s o n 10 # p l a y e r 1 class Person 2 def initialize( name, surname ) 3 puts name + " " + surname 4 end 5 end 6 person = Person. new( " Stanis ław", " Polak " ) 7 Stanis ł aw Polak 8 => #<Person : 0 xb7da7d2c> Hierarchia dziedziczenia w Ruby 1.9 Hierarchia dziedziczenia w Ruby 1.8 Dr inż. Stanisław Polak 77 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 78 Przedmiot: Programowanie w języku Ruby Atrybuty Instancyjne Obiektowość 1 class Owoc = def wypisz_ilosc 5 class #Wbrew pozorom, warto ś ci ą ilosc nie j e s t 1 6 end 7 8 # attr writer : r o d z a j 9 def rodzaj=( r ) = r 11 end # attr reader : r o d z a j 14 def rodzaj 16 end attr accessor : stan # a t t r a c c e s s o r a t t r r e a d e r a t t r w r i t e r 19 end 20 ########################### 21 o = Owoc. new 22 puts o. wypisz_ilosc #Wypisze : NilClass 23 puts o. ilosc #... undefined method i l o s c for #<Owoc : 0 x d0> ( NoMethodError ) 24 o. rodzaj = " banan " 25 puts o. rodzaj # Wypisze : banan 26 ############################### 27 o = Owoc. new 28 o. rodzaj = " banan " 29 o. stan = " dojrzaly " 30 puts o. rodzaj # Wypisze : banan 31 puts o. stan # Wypisze : dojrzaly Dr inż. Stanisław Polak 79 Przedmiot: Programowanie w języku Ruby Atrybuty Klasowe 1 class Zwierze = def initialize += 1 6 end 7 8 def ilosc # metoda i n s t a n c y j n a 10 end def self. ilosc # metoda k l a s o w a 14 end 15 end 16 ######################### 17 puts Zwierze. ilosc #Wypisze : 0 18 ######################### 19 class Pies < Zwierze = end 22 ######################### 23 puts Pies. ilosc #Wypisze : puts Zwierze. ilosc #Wypisze : pies = Pies. new 26 puts pies. ilosc #Wypisze : puts Pies. ilosc #Wypisze : puts Zwierze. ilosc #Wypisze : 11 Obiektowość Dr inż. Stanisław Polak 80 Przedmiot: Programowanie w języku Ruby ateriały dla studentów Informatyki wydziału IET AGH w Krakowie

21 Obiektowość Obiektowość Metody 1 class Zwierze = 1 = 1 4 ################################### 5 ###### Metody i n s t a n c y j n e ######### 6 def obiekt 7 p self 8 end 9 ################################### 10 def ilosc end 13 ################################### 14 def ilosc end ################################### 19 ######### Metody k l a s o w e ########## 20 def Zwierze.ilosc end 23 ################################### 24 def self.ilosc end 27 end 28 ################################### z=zwierze. new 31 z. ilosc1 #Wypisze : n i l 32 z. ilosc2 #Wypisze : 1 33 z. obiekt #wypisze : #<Zwierze : 0 x d58> 34 Zwierze. ilosc1 #Wypisze : 1 35 Zwierze. ilosc2 #Wypisze : 1 Atrybuty klasowe, a atrybuty instancyjne klasy Atrybuty klasowe 1 class Zwierze i l o s c j e s t atrybutem klasowym d z i e l o n y m przez klas ę Zwierze i każdą z j e j p o d k l a s 3 # Kiedy t w o r z y s z i n s t a n c j ę k l a s y Zwierze l u b j e j p o d k l a s y, t j. P i e s, 4 # to warto ś ć z m i e n n e j i l o s c zwi ę k s z a s i ę = def initialize 8 self. class. ilosc += 1 9 end def self. ilosc 13 end 14 def self. ilosc=(wartosc ) = wartosc 16 end 17 end class Pies < Zwierze 20 end times { Zwierze. new } times { Pies. new } p Zwierze. ilosc #Wypisze : p Pies. ilosc #Wypisze : 12 Atrybuty instancyjne klasy 1 class Zwierze 2 ilosc jest atrybutem instancyjnym (wył ą c z n i e ) k l a s y Zwierze 3 # Wartość zmiennej i l o s c ulega zwię kszeniu, t y l k o wtedy gdy t w o r z y s z i n s t a n c j ę k l a s y Z w i e r z e 4 # ( n i e p odklas y, t j. P i e s ) = def initialize 8 self. class. ilosc += 1 9 end def self. ilosc 13 end 14 def self. ilosc=(wartosc ) = wartosc 16 end 17 end class Pies < Zwierze = 0 21 end times { Zwierze. new } times { Pies. new } p Zwierze. ilosc #Wypisze : 8 27 p Pies. ilosc #Wypisze : 4 Dr inż. Stanisław Polak 81 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 82 Przedmiot: Programowanie w języku Ruby Obiektowość Obiektowość Dostęp do metody klasowej z wnętrza metody instancyjnej Obiekt main 1 class Zwierze 2 def metodainstancyjna 3 puts " Jestem metod ą instancyjn ą" 4 self.class.metodaklasowa 5 end 6 7 def self. metodaklasowa 8 puts " Jestem metod ą klasow ą" 9 end 10 end 11 ############################## 12 z = Zwierze. new 13 z. metodaklasowa #Bł ąd wykonania : undefined method metodaklasowa ############################## 15 z. metodainstancyjna 16 =begin 17 #Wypisze : 18 Jestem metod ą instancyjn ą 19 Jestem metod ą klasow ą 20 =end 1 def funkcja 2 puts " Jestem metod ą obiektu main " 3 end 4 5 class Klasa 6 def metoda 7 puts " Jestem metod ą obiektu Klasa " 8 funkcja ( ) 9 end 10 end puts self #Wypisze : main 13 puts self. class #Wypisze : O b j e c t o=klasa. new 16 o. metoda #Wypisze : Jestem metodą o b i e k t u Klasa 17 # Jestem metodą obiektu main Dr inż. Stanisław Polak 83 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 84 Przedmiot: Programowanie w języku Ruby

22 Obiektowość Obiektowość Moduły Metody klas oraz modułów Sterowanie kolejnością wykonywania 1 Math.sqrt ( 2 ) # => Math::PI # => ########################## 4 module Brzeczyk 5 def dzwon 6 puts " BZZZZ! BZZZZ! BZZZZ!" 7 end 8 end 9 ########################## 10 class Czasomierz 11 def podaj_czas 12 puts Time. now 13 end 14 end 15 ########################## 16 class Budzik < Czasomierz 17 include Brzeczyk 18 end 19 ########################## 20 b = Budzik. new 21 b. podaj_czas # Sun Aug : 2 4 : b. dzwon # BZZZZ! BZZZZ! BZZZZ! 23 Budzik. dzwon #u n d e f i n e d method dzwon f o r Budzik : C l a s s ( NoMethodError ) 1 class Budzik < Czasomierz 2 extend Brzeczyk 3 end 4 ########################## 5 b = Budzik. new 6 b. podaj_czas # Sun Aug : 2 4 : b. dzwon # u n d e f i n e d method dzwon f o r #<Budzik : 0 x c0c8> ( NoMethodError ) 8 Budzik. dzwon #BZZZZ! BZZZZ! BZZZZ! 9 zegarek = Czasomierz. new 10 zegarek. extend( Brzeczyk ) 11 zegarek. dzwon # BZZZZ! BZZZZ! BZZZZ! 1 module Brzeczyk 2 def podaj_czas 3 puts " Brzeczyk : " + Time. now. to_s 4 super 5 end 6 end 7 ########################## 8 class Czasomierz 9 def podaj_czas 10 puts " Czasomierz : " + Time. now. to_s 11 end 12 end 13 ########################## class Budzik < Czasomierz 16 include Brzeczyk 17 def podaj_czas 18 puts " Budzik : " + Time. now. to_s 19 super 20 end 21 end Budzik. new. podaj_czas Na wyjściu Budzik: :29: Brzeczyk: :29: Czasomierz: :29: module Brzeczyk 2 def podaj_czas 3 puts " Brzeczyk : " + Time. now. to_s 4 super 5 end 6 end 7 ########################## 8 class Czasomierz 9 def podaj_czas 10 puts " Czasomierz : " + Time. now. to_s 11 end 12 end 13 ########################## class Budzik < Czasomierz 16 prepend Brzeczyk #Dostępne w Ruby >= def podaj_czas 18 puts " Budzik : " + Time. now. to_s 19 super 20 end 21 end Budzik. new. podaj_czas Na wyjściu Brzeczyk: :31: Budzik: :31: Czasomierz: :31: Dr inż. Stanisław Polak 85 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 86 Przedmiot: Programowanie w języku Ruby Obiektowość Obiektowość Sprawdzanie typu obiektu 1 module Man 2 end 3 4 module Woman 5 end 6 7 class Person 8 include Man 9 end class Player < Person 12 include Woman 13 end p = Player. new 16 p. kind of? Player #t r u e 17 p. kind of? Person #t r u e 18 p. kind of? Man #t r u e 19 p. kind of? Woman #t r u e 20 #kind of? <=> is a? p. instance of? Player #t r u e 23 p. instance of? Person #f a l s e 24 p. instance of? Man #f a l s e 25 p. instance of? Woman #f a l s e Dr inż. Stanisław Polak 87 Przedmiot: Programowanie w języku Ruby Kontrola dostępu 1 class Test 2 public # ka ż da metoda ( poza i n i t i a l i z e ( ), kt ó r a j e s t prywatna ) j e s t domy ś l n i e p u b l i c z n a 3 def pub_met1 4 end 5 6 private # metoda prywatna 7 def priv_met1 8 end 9 10 protected # wymienione n i ż e j metody s ą c h r o n i o n e 11 def prot_met1 12 end def prot_met2 15 end 16 end 1 class Test 2 def pub_met1 3 end 4 5 def priv_met1 6 end 7 8 def prot_met1 9 end public : pub_met1 12 private : priv_met1 13 protected : prot_met1 14 end Dr inż. Stanisław Polak 88 Przedmiot: Programowanie w języku Ruby

23 Kontrola dostępu Przykład użycia Obiektowość 1 class Foo 2 def a ; end 3 4 # Wywoł a n i e a ( ) z jawnym s e l f jako o d b i o r c ą 5 def b ; self. a ; end 6 7 # Wywoł a n i e metody a ( ) z niejawnym s e l f jako o d b i o r c ą 8 def c ; a ; end 9 10 protected : a 11 end 12 ####################################### 13 class Foo1 < Foo 14 end 15 ####################################### 16 def safe_send ( receiver, method, message ) 17 # Nie moż na u ż ywać send ( ), poniewa ż omija zasady widoczno ś ci 18 eval " receiver.#{ method }" 19 rescue => e 20 puts "#{ message }: #{e}" 21 else 22 puts "#{ message }: wywo ł anie metody powiod ło się" 23 end 24 ####################################### 25 foo = Foo. new 26 foo1 = Foo1. new 27 safe_send (foo, : a, " jawny odbiorca " ) 28 safe_send (foo, : b, " jawny odbiorca self " ) 29 safe_send (foo, : c, " niejawny odbiorca self " ) 30 safe_send (foo1, : a, " jawny odbiorca " ) 31 safe_send (foo1, : b, " jawny odbiorca self " ) 32 safe_send (foo1, : c, " niejawny odbiorca self " ) skrypt.rb 1 $ ruby skrypt. rb 2 jawny odbiorca : wywo ł anie metody powiod ło si ę 3 jawny odbiorca self : wywo ł anie metody powiod ło si ę 4 niejawny odbiorca self : wywo ł anie metody powiod ło si ę 5 jawny odbiorca : wywo ł anie metody powiod ło si ę 6 jawny odbiorca self : wywo ł anie metody powiod ło si ę 7 niejawny odbiorca self : wywo ł anie metody powiod ło si ę 1 $ ruby skrypt. rb 2 jawny odbiorca : protected method a called for #<Foo : 0 x a0960> 3 jawny odbiorca self : wywo ł anie metody powiod ło si ę 4 niejawny odbiorca self : wywo ł anie metody powiod ło si ę 5 jawny odbiorca : protected method a called for #<Foo1 : 0 x a0938> 6 jawny odbiorca self : wywo ł anie metody powiod ło si ę 7 niejawny odbiorca self : wywo ł anie metody powiod ło si ę 1 $ ruby skrypt. rb 2 jawny odbiorca : private method a called for #<Foo : 0 x b4840> 3 jawny odbiorca self : private method a called for #<Foo : 0 x b4840> 4 niejawny odbiorca self : wywo ł anie metody powiod ło si ę 5 jawny odbiorca : private method a called for #<Foo1 : 0 x b4818> 6 jawny odbiorca self : private method a called for #<Foo1 : 0 x b4818> 7 niejawny odbiorca self : wywo ł anie metody powiod ło si ę Dr inż. Stanisław Polak 89 Przedmiot: Programowanie w języku Ruby Model klient-serwer Usługa WWW Serwer WWW Adres IP Port Obsługa WWW Protokół Przeglądarka WWW Dr inż. Stanisław Polak 90 Przedmiot: Programowanie w języku Ruby Materiały dla studentów Informatyki wydziału IET AGH w Krakowie Obsługa WWW Obsługa WWW Wybrane komendy (metody) protokołu HTTP Wysyłanie danych z formularza HTML Komenda GET 1 GET / index. html HTTP / Host : www. icsr. agh. edu. pl 3 Żądanie 1 HTTP / OK 2 Date : Mon, 09 Aug : 0 2 : 0 8 GMT 3 Server : Apache / ( UNIX ) 4 Content Length : Content Type : text / html ; charset=utf <! DOCTYPE html> 8 <html> </ html> Odpowiedź Komenda POST 1 POST /cgi bin / search. cgi HTTP /1.1 2 Host : www. icsr. agh. edu. pl 3 Content Length : query=alpha+complex&casesens=false&cmd= submit Żądanie 1 HTTP / OK 2 Date : Mon, 09 Aug : 0 2 : 2 0 GMT 3 Server : Apache / ( UNIX ) 4 Content Length : Content Type : text / html ; charset=utf 8 6 Connection : close 7 8 <! DOCTYPE html> 9 <html> </ html> Odpowiedź Zatwierdzanie danych kodowanie wysyłanie do serwera WWW 1 <form method ="... " enctype ="... " a c t i o n="... "> </ form> GET POST application/x-www-formurlencoded multipart/form-data Dr inż. Stanisław Polak 91 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 92 Przedmiot: Programowanie w języku Ruby

24 Obsługa WWW Obsługa WWW Kodowanie application/x-www-form-urlencoded Przykład Kodowanie multipart/form-data Przykład 1 <form action="http :// www. serwer.com / skrypt "> 2 Login : <input name=" login " type=" TEXT "><br> 3 Has ł o : <input name=" haslo " type=" PASSWORD "> 4 </ form> Login: Hasło: Jan Kowalski (Nowak) 1 login=jan&haslo=kowalski+%28nowak%29 Dokument HTML Zakodowane dane 1 <form action="... " method=" POST " e n c t y p e=" multipart /form - data "> 2 <input name=" login " type=" TEXT "> 3 <input name=" haslo " type=" PASSWORD "> 4 <input name=" plik " type=" FILE " a c c e p t=" image /jpeg, image / gif "> 5 </ form> Jan Kowalski (Nowak) obraz.jpg 1 POST / skrypt HTTP / Content Length : Content Type : multipart /form data ; boundary= Content Disposition : form data ; name=" login " 7 8 Jan Content Disposition : form data ; name=" haslo " Kowalski ( Nowak ) Content Disposition : form data ; name="plik " ; filename="obraz.jpg " 15 Content Type : image / jpeg 16 Content Transfer Encoding : binary Zawarto ś ć pliku obraz. jpg Dr inż. Stanisław Polak 93 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 94 Przedmiot: Programowanie w języku Ruby Obsługa WWW Obsługa WWW Podstawowe protokoły do komunikacji z serwerem WWW Przykład programu używającego protokołu CGI Język C CGI Serwer WWW 80 Przeglądarka WWW Proces FastCGI Serwer WWW 80 Proces... Proces GET / POST GET / POST dane Przeglądarka WWW dane 1 # include <s t d i o. h> 2 # include <s t d l i b. h> 3 main ( argc, argv ) 4 int argc ; 5 char argv ; 6 { 7 char bufor ; 8 int rozmiar ; 9 10 // S p e c y f i k a c j a typu zawarto ś c i 11 printf ( " Content - type : text / plain \n\n" ) ; 12 if (getenv ( " REQUEST_METHOD " ) ){ // Je ś l i do k o m u n i k a c j i z serwerem u ż y t o metody GET 15 if (! strcasecmp (getenv ( " REQUEST_METHOD " ), " get " ) ) 16 //W przypadku metody GET dane z f o r m u l a r z a s w z m ą i e n n e j ś r o d o w i s k o w e j QUERY STRING 17 printf ( " QUERY_STRING zawiera : %s\n",getenv ( " QUERY_STRING " ) ) ; // Je ś l i do k o m u n i k a c j i z serwerem u ż y t o metody POST 20 if (getenv ( " REQUEST_METHOD " ) &&! strcasecmp (getenv ( " REQUEST_METHOD " ), " post " ) ) { 21 //W przypadku metody POST dane z f o r m u l a r z a s ą d o s t ę pne za pomocą standardowego wej ś c i a (STDIN) l i j e s t d o s t ę pna zmienna ś rodowiskowa 22 // Je ś CONTENT LENGTH 23 if (getenv ( " CONTENT_LENGTH " ) ) { 24 printf ( " Czytam ze standardowego wejscia \n" ) ; 25 printf ( "Content -Type =%s\n",getenv ( " CONTENT_TYPE " ) ) ; 26 printf ( "Content - Length =%s\n",getenv ( " CONTENT_LENGTH " ) ) ; 27 //w przypadku metody POST z STDIN musimy p r z e c z y t a ć t y l e b a j t ów, i l e o k r e ś l o n o w z m i e n n e j ś r o d o w i s k o w e j CONTENT LENGTH 28 rozmiar=atoi (getenv ( " CONTENT_LENGTH " ) ) ; 29 bufor=(char )calloc (rozmiar +1,sizeof (int ) ) ; 30 if ( bufor ){ 31 fread ( bufor, rozmiar, sizeof ( char ), stdin ) ; 32 bufor [ rozmiar ]= \0 ; 33 fwrite ( bufor, rozmiar, sizeof ( char ), stdout ) ; 34 } 35 } 36 } 37 } 38 else 39 printf ( " Brak danych \n" ) ; 40 return 0 ; 41 } Dr inż. Stanisław Polak 95 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 96 Przedmiot: Programowanie w języku Ruby

25 Obsługa WWW Obsługa WWW Przykład działania programu Metoda GET Przykład działania programu Metoda POST Dr inż. Stanisław Polak 97 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 98 Przedmiot: Programowanie w języku Ruby Protokoły CGI oraz FastCGI Obsługa WWW Obsługa CGI Przykład Hello World 1 #! / u s r / b i n / ruby 2 require cgi 3 4 cgi = CGI. new ( " html5 " ) 5 6 cgi. out { 7 cgi. html { 8 cgi. body { 9 cgi. h1 { " Hello World!" } 10 } 11 } 12 } skrypt.rb 1 $ chmod 755. / skrypt. rb 2 $. / skrypt. rb 3 ( offline mode : enter name=value pairs on standard input ) 4 Content Type : text / html 5 Content Length : <!DOCTYPE HTML><HTML><BODY><H1>Hello World!</H1></BODY></HTML> Dr inż. Stanisław Polak 99 Przedmiot: Programowanie w języku Ruby Protokoły CGI oraz FastCGI Obsługa WWW Obsługa formularzy HTML 1 <form action="/cgi -bin / skrypt.rb"> 2 <input type=" TEXT " name="a" value="1" /> 3 <input type=" TEXT " name="b" value="2" /> 4 <input type=" TEXT " name="a" value="3" /> </ form> Względny URL: /cgi-bin/skrypt.rb?a=1&b=2&a=3 1 #! / u s r / b i n / ruby 2 require cgi 3 4 cgi=cgi. new 5 puts cgi. http_header 6 7 #Pierwszy spos ób 8 puts cgi [ a ] #wypisze : 1 9 puts cgi [ b ] #wypisze : 2 10 puts cgi [ a ]. class #wypisze : S t r i n g #Drugi spos ób 13 puts cgi. params [ a ] [ 0 ] #w y p i s z e : 1 14 puts cgi. params [ a ] [ 1 ] #w y p i s z e : 3 15 puts cgi. params [ b ] [ 0 ] #w y p i s z e : 2 16 puts cgi. params [ a ]. class #w y p i s z e : A r r a y #Trzeci spos ób 19 parametry=cgi. params #pobieramy warto ś c i w s z y s t k i c h pó l f o r m u l a r z a 20 puts parametry [ a ] [ 0 ] #w y p i s z e : 1 21 puts parametry [ a ] [ 1 ] #w y p i s z e : 3 22 puts parametry [ b ] [ 0 ] #w y p i s z e : 2 23 puts parametry. class #wypisze : Hash skrypt.rb Dr inż. Stanisław Polak 100 Przedmiot: Programowanie w języku Ruby ateriały dla studentów Informatyki wydziału IET AGH w Krakowie

26 Protokoły CGI oraz FastCGI Obsługa WWW Przesyłanie plików na serwer Protokoły CGI oraz FastCGI Obsługa WWW Obsługa ciasteczek 1 <form method="post " e n c t y p e=" multipart / form -data " action="/cgi -bin / upload.rb"> 2 <label>plik :<input type=" file " name=" plik "/></ label> <br /> 3 <input type=" submit " value="wyślij!" / > 4 </ form> 1 #! / u s r / b i n / ruby 2 require cgi 3 4 cgi = CGI. new 5 puts cgi. http_header 6 parametry = cgi. params 7 if parametry. has_key?" plik " 8 plik = parametry [ "plik " ]. first 9 plik_serwer = pliki / + plik. original_filename " 10 File.open ( plik_serwer.untaint, "w") do f 11 f << plik. read 12 end 13 end upload.rb 1 #! / u s r / b i n / ruby 2 require " cgi " 3 cookie = CGI : : Cookie. new ( " rubyweb ", " CustID =123 ", " Part = ABC " ) ; #Warto ś c i ą c i a s t e c z k a rybyweb j e s t n a p i s CustID%3D123&Part%3DABC 4 cgi = CGI. new ( " html5 " ) 5 cgi. out ( " cookie " => [ cookie ] ){ 6 cgi. html{ 7 "\ nhtml content here " 8 } 9 } Ustawienie wartości ciasteczka 1 #! / u s r / b i n / ruby 2 require " cgi " 3 cgi = CGI. new ( " html5 " ) 4 cgi. out{ 5 cgi. html{ 6 cgi. pre{ 7 cookie = cgi. cookies [ " rubyweb " ] 8 "\ ncookies are \n" + cookie. value. join ( "\n" ) 9 } 10 } 11 } Odczytanie wartości ciasteczka Dr inż. Stanisław Polak 101 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 102 Przedmiot: Programowanie w języku Ruby Protokoły CGI oraz FastCGI Obsługa WWW Obsługa sesji Protokoły CGI oraz FastCGI Obsługa WWW Obsługa FastCGI Przykład Hello World 1 #! / u s r / b i n / ruby 2 require " cgi " 3 require "cgi / session " 4 5 cgi = CGI. new ( " html5 " ) 6 sess = CGI : : Session. new ( cgi ) #Z o s t a n i e utworzone c i a s t e c z k o,, s e s s i o n i d 7 sess [ " CustID " ] = sess [ "Part " ] = "ABC " 9 10 cgi. out{ 11 cgi. html{ 12 "\ nhtml content here " 13 } 14 } 1 #! / u s r / b i n / ruby 2 require " cgi " 3 require "cgi / session " 4 5 cgi = CGI. new ( " html5 " ) 6 sess = CGI : : Session. new ( cgi ) 7 cgi. out{ 8 cgi. html{ 9 "\ ncustomer #{ sess [ CustID ]} orders an #{ sess [ Part ]}" 10 } 11 } 1 #! / u s r / b i n / ruby 2 require " fcgi " 3 4 FCGI. each do request 5 out = request. out 6 out. print " Content - Type : text / plain \r\n" 7 out. print "\r\n" 8 out. print " Hello World " 9 request. finish 10 end 1 #! / u s r / b i n / ruby 2 require " fcgi " 3 4 FCGI. each cgi do cgi 5 puts cgi. header 6 puts " Hello World " 7 end Użycie natywnego interfejsu FastCGI Użycie interfejsu kompatybilnego z CGI Dr inż. Stanisław Polak 103 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 104 Przedmiot: Programowanie w języku Ruby

27 Interfejs Rack Obsługa WWW Rack Interfejs Rack Obsługa WWW Użycie Rack Przykład 1 Wspólny interfejs pomiędzy serwerem WWW a aplikacją Ruby jest tym dla frameworków Rubiego czym specyfikacja CGI dla skryptów CGI. Umożliwia komunikację (ang. interfacing) aplikacji webowej z serwerem WWW, inną aplikacją lub frameworkiem webowym Rack obsługuje wszystkie, specyficzne dla serwerów WWW, wywołania API, przekazuje aplikacji treść żądania HTTP oraz wszystkie parametry środowiska w postaci hash-a oraz zwraca serwerowi odpowiedź od aplikacji Aplikacja nie musi wiedzieć, jak rozmawiać z serwerem HTTP, za to musi wiedzieć, jak rozmawiać z Rack -iem 1 class HelloWorld 2 def call ( env ) 3 return [ 2 0 0, {}, [ " Hello world!" ] ] 4 end 5 end Prosta aplikacja Rack 1 #! / u s r / b i n / env ruby 2 require rack 3 4 class HelloWorld 5 def call ( env ) 6 sleep ( 1 0 ) #uś p i j program na 10 sekund 7 return [ 2 0 0, {}, [ " Hello world!" ] ] 8 end 9 end Rack : : Handler : : WEBrick. run( 12 HelloWorld. new, 13 : Port => ) helloworld.rb 1 $ chmod 755. / helloworld. rb 2 $. / helloworld. rb 3 [ : 4 3 : 1 6 ] INFO WEBrick [ : 4 3 : 1 6 ] INFO ruby ( ) [ x86_64 linux ] 5 [ : 4 3 : 1 6 ] INFO WEBrick : : HTTPServer#s t a r t : p i d =9026 p o r t = localhost [14/ Apr / : 1 0 : 4 4 : 0 4 CEST ] " GET / HTTP /1.1 " > / 1 $ curl localhost : Hello world! Dr inż. Stanisław Polak 105 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 106 Przedmiot: Programowanie w języku Ruby Interfejs Rack Obsługa WWW Użycie Rack Przykład 2 Interfejs Rack Obsługa WWW Parametr env 1 class HelloWorld 2 def call ( env ) 3 return [ 4 200, 5 { Content-Type => text/html }, 6 [ " Hello world!" ] 7 ] 8 end 9 end run HelloWorld. new helloworld.ru 1 $ rackup helloworld. ru Listening on tcp : / / : $ rackup -p 1337 helloworld. ru Listening on tcp : / / : $ curl localhost : Hello world! 1 class HelloWorld 2 def call (env) 3 odpowied ź=env. map do klucz, warto ś ć 4 klucz. to_s+"="+warto ś ć. to_s+"<br >" 5 end 6 return [ 7 200, 8 { Content - Type => text / html ; charset=utf -8 }, 9 odpowied ź 10 ] 11 end 12 end helloworld.rb Dr inż. Stanisław Polak 107 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 108 Przedmiot: Programowanie w języku Ruby

28 Interfejs Rack Obsługa WWW Obsługa formularzy HTML 1 <form action="http :// localhost :9292/ "> 2 <input type=" TEXT " name="a" value="ą" /> 3 <input type=" TEXT " name="b" value="(" /> 4 <input type=" TEXT " name="a" value="1" /> 5 <input type=" SUBMIT "> 6 </ form> 1 class HelloWorld 2 def call ( env ) 3 odpowied ź = "" 4 #Odczytywanie danych otrzymanych od p r z e g l ą d a r k i 5 odpowied ź << env [ QUERY STRING ] #Dane otrzymane ( metod ą GET) od p r z e g l ą d a r k i 6 odpowied ź << env [ rack.input ]. read # Dane otrzymane ( metod ą POST) od p r z e g l ą d a r k i 7 8 #Wysy ł a n i e o d p o w i e d z i do p r z e g l ą d a r k i 9 return [ , 11 { Content - Type => text / html }, 12 [ odpowied ź ] 13 ] 14 end 15 end helloworld.rb Dr inż. Stanisław Polak 109 Przedmiot: Programowanie w języku Ruby Interfejs Rack Obsługa WWW Obsługa formularzy HTML Obiekt Rack::Response 1 class HelloWorld 2 def call ( env ) 3 req = Rack : : Request. new ( env ) 4 res = Rack::Response. new 5 res. write ( "a="+req. params [ a ] [ 0 ] + "<br >" ) #D o p i s u j e podany t e k s t do c i a ł a o d p o w i e d z i 6 res. write ( "a="+req. params [ a ] [ 1 ] + "<br >" ) 7 res. write ( "b="+req. params [ b ] ) 8 res [ Content -Type ] = text /html ; charset=utf -8 #Ustawienie nag ł ówka Content type 9 res. status = 200 #zb ędne, gdy ż j e s t to domyś lny kod statusu 10 res. finish #zwr ó ć odpowied ź w p o s t a c i ( t r z y e l e m e n t o w e j ) t a b l i c y 11 end 12 end helloworld.rb Interfejs Rack Obsługa WWW Obsługa formularzy HTML Obiekt Rack::Request 1 <form action="http :// localhost :9292/ "> 1 class HelloWorld 2 <input type=" TEXT " name="a[]" v a l u e="ą" / 2 def call ( env ) > 3 req = Rack::Request. new ( env ) 3 <input type=" TEXT " name="b" value="(" /> 4 odpowied ź = [ 4 <input type=" TEXT " name="a[]" v a l u e="1" / 5 "a="+req. params [ a ] [ 0 ] + "<br >", > 6 "a="+req. params [ a ] [ 1 ] + "<br >", 5 <input type=" SUBMIT "> 7 "b="+req. params [ b ] # zamiast req. 6 </ form> params [ b ] moż na u ż y ć r e q [ b ] 8 ] 9 return [ , 11 { Content - Type => text / html ; charset=utf -8 }, 12 odpowied ź 13 ] 14 end 15 end helloworld.rb Dr inż. Stanisław Polak 110 Przedmiot: Programowanie w języku Ruby Materiały dla studentów Informatyki wydziału IET AGH w Krakowie Interfejs Rack Obsługa WWW Tworzenie Middleware 1 # Ź r ód ł o : h t t p : / / code. t u t s p l u s. com/ a r t i c l e s / e x p l o r i n g rack net class ToUpper 3 # Our c l a s s w i l l be i n i t i a l i z e w i t h a n o t h e r Rack app 4 def initialize( app ) = app 6 end 7 8 def call( env ) 9 # F i r s t, c a l 10 status, headers, body call ( env ) # I t e r a t e through the body, upcasing each chunk 13 upcased_body = body. map { chunk chunk. upcase } # Pass our new body on t h r o u g h 16 [ status, headers, upcased_body ] 17 end 18 end 19 ################################################# 20 class Hello 21 def self. call ( env ) 22 [ 200, {"Content -Type " => "text / plain " }, [ " Hello from Rack!" ] ] 23 end 24 end 25 ################################################# 26 use ToUpper # T e l l Rack to use our newly minted middleware 27 run Hello 28 # Odpowiednik : app = ToUpper.new(Hello) ; run app config.ru Dr inż. Stanisław Polak 111 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 112 Przedmiot: Programowanie w języku Ruby

29 Podstawy języka dziedzinowego Sinatra Podstawy języka dziedzinowego Sinatra Sinatra Zalety Mały i elastyczny język typu DSL (ang. Domain-Specific Language) do szybkiego tworzenia aplikacji internetowych w Ruby Alternatywa dla frameworków takich jak np. Ruby on Rails czy Merb Korzysta z interfejsu Rack Nie korzysta z paradygmatu Model-Widok-Kontroler Źródło inspiracji dla wielu frameworków, m.in., Express (JavaScript) oraz Padrino (Ruby) Nazwa pochodzi od nazwiska piosenkarza Franka Sinatry Autor: Blake Mizerany Duża szybkość tworzenia prostych aplikacji Brak ciężkości Ruby on Rails Lekkość Wady Nie nadaje się do tworzenia złożonych aplikacji Stosunkowo mała liczba wtyczek Przykład Hello World 1 require sinatra 2 3 get / witaj do 4 " Witaj Ś wiecie \n" 5 end skrypt.rb 1 $ ruby skrypt. rb 2 [ : 1 6 : 2 8 ] INFO WEBrick [ : 1 6 : 2 8 ] INFO ruby ( ) [ x86_64 linux ] 4 == Sinatra / has taken the stage on 4567 for development with backup from WEBrick 5 [ : 1 6 : 2 8 ] INFO WEBrick : : HTTPServer#s t a r t : pid =23737 port = $ curl http : / / localhost :4567/ witaj 2 Witaj Świecie Uruchamianie aplikacji Wykonywanie żądania Dr inż. Stanisław Polak 113 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 114 Przedmiot: Programowanie w języku Ruby Podstawy języka dziedzinowego Sinatra Podstawy języka dziedzinowego Sinatra Trasy Definiowanie Trasy Dopasowywanie 1 get / do 2.. wyświetl coś.. 3 end 4 5 post / do 6.. utw órz co ś.. 7 end 8 9 put / do 10.. zast ąp co ś.. 11 end patch / do 14.. zmodyfikuj co ś.. 15 end delete / do 18.. unicestw co ś.. 19 end get / witaj do 2 " Pierwsza trasa \ nhasz params zawiera : #{params. inspect }\n" 3 end 4 5 get / witaj do #Ta t r a s a n i e z o s t a n i e ( n i g d y ) dopasowana 6 " Druga trasa \ nhasz params zawiera : #{ params. inspect }\n" 7 end 8 9 get / witaj /:nazwa do 10 " Trzecia trasa \ nhasz params zawiera : #{params. inspect }\n" 11 end 1 $ curl http : / / localhost :4567/ witaj 2 Pierwsza trasa 3 hasz params zawiera : {} 4 $ curl http : / / localhost :4567/ witaj?imie=stanislaw&nazwisko=polak 5 Pierwsza trasa 6 hasz params zawiera : {"imie "=>" Stanislaw ", " nazwisko "=>" Polak "} 7 $ curl http : / / localhost :4567/ witaj /Swiecie 8 Trzecia trasa 9 hasz params zawiera : {" splat "=>[], " captures "=>[" Swiecie " ], " nazwa "=>" Swiecie " } 10 $ curl http : / / localhost :4567/ witaj /Swiecie? imie=stanislaw&nazwisko=polak 11 Trzecia trasa 12 hasz params zawiera : {"imie "=>" Stanislaw ", " nazwisko "=>" Polak ", " splat "=>[], " captures "=>[" Swiecie " ], " nazwa "=>" Swiecie "} Dr inż. Stanisław Polak 115 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 116 Przedmiot: Programowanie w języku Ruby

30 Podstawy języka dziedzinowego Sinatra Podstawy języka dziedzinowego Sinatra Wartości zwracane przez blok trasy Szablon Użycie szablonu ERB 1 get / witaj do 2 erb(witaj) #R e n d e r u j s z a b l o n v i e w s / w i t a j. e r b 3 end Trzyelementowa tablica: [status (Fixnum), nagłówki (Hash), ciało odpowiedzi (reagujące na wywołanie metody each())] Dwuelementowa tablica: [status (Fixnum), ciało odpowiedzi (reagujące na wywołanie metody each())] Obiekt, który reaguje na wywołanie metody each() i nie przekazuje nic, oprócz napisu, do danego bloku Wartość typu Fixnum reprezentująca kod statusu 1 <%# To jest komentarz %> 2 <%# Poni ż e j j e s t s k r y p t l e t %> 3 <% 3. downto (0) do i %> 4 <%# Poni ż e j j e s t wyra ż e n i e %> 5 <%= i %>, 6 <% end %> 7 Start skrypt.rb views/witaj.erb 1 $ curl http : / / localhost :4567/ witaj 2 3, 3 2, 4 1, 5 0, 6 Start Wykonywanie żądania Dr inż. Stanisław Polak 117 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 118 Przedmiot: Programowanie w języku Ruby Szablon inline 1 require sinatra 2 3 get / witaj do 4 erb (witaj) 5 end 6 END 7 9 <%# To j e s t komentarz %> 10 <%# Poni ż e j j e s t s k r y p t l e t %> 11 <% 3. downto (0) do i %> 12 <%# Poni ż e j j e s t wyra ż e n i e %> 13 <%= i %>, 14 <% end %> 15 Start Podstawy języka dziedzinowego Sinatra skrypt.rb Dr inż. Stanisław Polak 119 Przedmiot: Programowanie w języku Ruby Szablon częściowy 1 require sinatra 2 3 get / do 4 erb ( : index ) 5 end skrypt.rb 1 <%= e r b ( : w i t a j ) %> 2 <%= e r b ( : s w i e c i e ) %> 1 Witaj 1 Świecie views/index.erb views/witaj.erb views/swiecie.erb Podstawy języka dziedzinowego Sinatra 1 $ curl http : / / localhost :4567/ 2 Witaj 3 Świecie Wykonywanie żądania Dr inż. Stanisław Polak 120 Przedmiot: Programowanie w języku Ruby ateriały dla studentów Informatyki wydziału IET AGH w Krakowie

31 Podstawy języka dziedzinowego Sinatra Podstawy języka dziedzinowego Sinatra Układ Dostęp do zmiennych z poziomu szablonu 1 <html> 2 <head> 3 <title>aplikacja Sinatra</ title> 4 </ head> 5 <body> 6 <h1>aplikacja Sinatra</h1> 7 <! pocz ą tek wstawki szablonu > 8 <%= yield %> 9 <! k o n i e c wstawki s z a b l o n u > 10 </ body> 11 </ html> views/layout.erb 1 <% 3. downto (0) do i %> 2 <%= i %>, 3 <% end %> 4 Start views/witaj.erb 1 $ curl http : / / localhost :4567/ witaj 2 <html> 3 <head> 4 <title>aplikacja Sinatra</title> 5 </head> 6 <body> 7 <h1>aplikacja Sinatra</h1> 8 <! początek wstawki szablonu > 9 3, 10 2, 11 1, 12 0, 13 Start <! koniec wstawki szablonu > 16 </body> 17 </html> Wykonywanie żądania 1 require sinatra 2 3 get / witaj do = " Witaj " #Zmienna i n s t a n c y j n a j e s t d o s t ę pna z poziomu s z a b l o n u 5 tekst2 = "Ś wiecie " #Zwyk ł a zmienna nie j e s t dost ępna z poziomu szablonu 6 erb ( : witaj, :locals => {:tekst3 => tekst2 }) #Definiowanie, dla szablonu w i t a j, z m i e n n e j l o k a l n e j t e k s t 3 7 end 1 %> <%= tekst3 %> 1 $ curl http : / / localhost :4567/ witaj 2 Witaj Świecie skrypt.rb views/witaj.erb Wykonywanie żądania Dr inż. Stanisław Polak 121 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 122 Przedmiot: Programowanie w języku Ruby Podstawy języka dziedzinowego Sinatra Źródła Przykład Przetwarzanie zawartości formularza Źródła I 1 require sinatra 2 3 get / formularz do 4 erb : formularz 5 end 6 7 post / formularz do 8 " Pole nazwa zawiera napis #{params[: nazwa ]} " 9 end skrypt.rb James Britt. cgi.rb - cgi support library. Jamis Buck. Method visibility in Ruby. http: //weblog.jamisbuck.org/2007/2/23/method-visibility-in-ruby. Radosław Bułat. Blog. 1 <form action="/formularz" method="post"> 2 <input type="text " name=" nazwa "> 3 <input type=" submit "> 4 </ form> views/formularz.erb Yukihiro Matsumoto. Programming Ruby. The Pragmatic Programmer s Guide. Blake Mizerany. Sinatra - documentation. Dr inż. Stanisław Polak 123 Przedmiot: Programowanie w języku Ruby Dr inż. Stanisław Polak 124 Przedmiot: Programowanie w języku Ruby