Ruby	  Workshop	  –	  Skriptum	  Julian	  Fischer,	  Clemens	  Kofler	  München,	  19.-­‐21.	  Dezember	  2011	  	        ...
Installation	  ..............................................................................................................
Query-­‐/Predicate-­‐Methoden	  .............................................................................................
Status	  der	  Standard-­‐Library	  .........................................................................................
Monkeypatching	  ............................................................................................................
Capybara	  ..................................................................................................................
Installation	  In	  diesem	  Kapitel	  wird	  das	  Setup	  einer	  Ruby-­‐Entwicklungsumgebung	  unter	  Linux	  (z.B.	  ...
Hinweis:	  Bei	  Verwendung	  einer	  anderen	  Shell	  muss	  ggf.	  eine	  andere	  Konfigurationsdatei	  bearbeitet	  w...
Literaturempfehlungen	  Gratis	  https://rvm.beginrescueend.com/	  http://screencasts.org/episodes/how-­‐to-­‐use-­‐rvm	  ...
Git	  Crashkurs	  Git	  ist	  ein	  mächtiges	  Versionskontrollsystem.	  In	  diesem	  Abschnitt	  soll	  eine	  kurze	  ...
Commit	  Im	  Gegensatz	  zu	  anderen	  Versionskontrollsystemen	  wie	  z.B.	  Subversion	  erfolgt	  ein	  Commit	  in	...
Ruby	  Basics	  Variablen	  Typisierung	  In	  Ruby	  ist,	  im	  Gegensatz	  zu	  Java	  und	  anderen	  strenger	  typis...
werden	  haben	  einen	  großen	  Anfangsbuchstaben	  und	  werden	  ohne	  Trennzeichen	             aneinander	  gekette...
Strings	  (Zeichenketten)	  Deklaration	  Strings	  können	  in	  Ruby	  single-­‐	  oder	  double-­‐quoted	  sein.	  Hall...
Veränderung	  eines	  Strings	  puts lang + Script                                # => JavaScriptputs lang.capitalize     ...
a * bendputs multiply(4, 3) # => 12Query-­‐/Predicate-­‐Methoden	  Als	  Query-­‐	  oder	  Predicate-­‐Methoden	  werden	 ...
p languages # => ["Java", "Ruby"]Aufgrund	  der	  dynamischen	  Typisierung	  kann	  ein	  Array	  in	  Ruby	  Elemente	  ...
puts [Java, C#, Ruby, JavaScript].join(, )# => Java, C#, Ruby, JavaScriptp ["Java", "Ruby", "Java"].uniq # => ["Java", "Ru...
Deklaration	  Hashes	  werden	  mit	  einer	  Literal-­‐Syntax	  deklariert.	  hash = { a => 100, b => 50, c => 10 }p hash...
puts hash.empty?                                       # => falseputs hash.has_key?(b)                                # =>...
WEST = 4def move(direction)    if direction == NORTH         moveNorth    # ...    endendmove(NORTH)Dieser	  Code	  wird	 ...
•    reject:	  selektiert	  alle	  Elemente,	  für	  die	  der	  übergebene	  Block	  false	  zurück	            gibt	    ...
Verwendung	  von	  externen	  Iteratoren	  Es	  ist	  möglich,	  eigenständige	  (externe)	  Iterator-­‐Objekte	  zu	  ver...
# => wrong number of arguments (0 for 1) (ArgumentError)Blöcke	  Methoden	  können	  optional	  einen	  Parameter	  als	  ...
 Kontrollstrukturen	  Ruby	  kennt	  ähnliche	  Kontrollstrukturen	  wie	  Java,	  um	  den	  Fluss	  des	  Programms	  zu...
unless x == 42    puts "Die Antwort ist 42, nicht #{x}!”endHinweis:	  unless	  +	  else	  sollte	  der	  Klarheit	  wegen	...
when 7    puts "Sonntag"when 6    puts "Samstag"else    puts "Immer noch nicht Wochenende :("endFür	  kurze	  Abschnitte	 ...
http://www.amazon.de/dp/1430223634	  (Beginning	  Ruby)	  ©	  2011,	  Julian	  Fischer	  und	  Clemens	  Kofler	  
Standard-­‐Library	  und	  Gems	  Ruby	  unterteilt	  sich	  in	  eine	  Core-­‐	  und	  Standard-­‐Library:	  Während	  d...
Verwendung	  Gems	  können	  entweder	  direkt	  über	  RubyGems	  oder	  mit	  Bundler	  verwendet	  werden.	  require ru...
•     Devise	       •     Sorcery	       •     OmniAuth	  (externe	  Auth	  Provider,	  z.B.	  Facebook)	       •     CanC...
Automatisierung	         •   guard	         •   foreman	  Internationalisierung	         •   i18n	         •   globalize	 ...
Bundler	  Bundler	  wird	  verwendet,	  um	  Abhängigkeiten	  unter	  verschiedenen	  Gems	  zu	  verwalten	  und	  aufzul...
Objektorientierte	  Programmierung	  mit	  Ruby	  –	  Grundlagen	  Klassen	  und	  Instanzen	  Ruby	  ist	  –	  wie	  Java...
matz = Person.newKlassenmethoden	  Klassenmethoden	  sind	  Methoden,	  die	  für	  eine	  Klasse	  zur	  Verfügung	  steh...
endhash = { :a => 1, :b => 2, :c => 3, :d => 4 }p values_in_hash(hash, :a, :c) # => [1, 3]Auch	  der	  umgekehrte	  Weg	  ...
# attr_reader :name    # attr_writer :nameendmatz = Person.newmatz.name = Matzputs matz.name# ohne Accessorclass Person   ...
Access	  Control	  (Zugriffskontrolle)	  Methoden	  können	  vor	  dem	  Zugriff	  geschützt	  werden.	  Dafür	  stehen	  ...
class Programmer < PersonendMethoden	  Klassen	  erben	  alle	  Methoden	  ihrer	  Superklasse.	  class Person    def init...
class Programmer < Person    def about_me        "#{super} (Programmer)"    endendmatz = Programmer.new(Matz)puts matz.abo...
Objektorientierte	  Programmierung	  mit	  Ruby	  –	  Fortgeschrittene	  Themen	  Ruby	  Objektmodell	  Alles	  in	  Ruby	...
endclass Person    attr_reader :first_name, :last_name    include Naming    def initialize(first_name, last_name)        @...
attr_reader :name    def initialize(name)        @name = name    end    def inspect        name    endendpeople = [Person....
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Ruby Grundlagen
Nächste SlideShare
Wird geladen in …5
×

Ruby Grundlagen

2.029 Aufrufe

Veröffentlicht am

Eine Einführung in die Grundlagen der wohl schönsten Programmiersprache der Neuzeit. Dabei werden auch verwandte Themen wie Git, Rubygems, REST Web-Services, TDD und BDD behandelt.

Veröffentlicht in: Technologie
0 Kommentare
0 Gefällt mir
Statistik
Notizen
  • Als Erste(r) kommentieren

  • Gehören Sie zu den Ersten, denen das gefällt!

Keine Downloads
Aufrufe
Aufrufe insgesamt
2.029
Auf SlideShare
0
Aus Einbettungen
0
Anzahl an Einbettungen
15
Aktionen
Geteilt
0
Downloads
16
Kommentare
0
Gefällt mir
0
Einbettungen 0
Keine Einbettungen

Keine Notizen für die Folie

Ruby Grundlagen

  1. 1. Ruby  Workshop  –  Skriptum  Julian  Fischer,  Clemens  Kofler  München,  19.-­‐21.  Dezember  2011      ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  2. 2. Installation  .........................................................................................................................  7  Vorbereitung  des  Systems  ...............................................................................................................................................  7  Installation  von  Ruby  mittels  RVM  ..............................................................................................................................  7   Installation  von  RVM  ..........................................................................................................................................................  7   Installation  von  Ruby  .........................................................................................................................................................  8   Auswahl  der  Ruby-­‐Version  ...............................................................................................................................................  8   Update  von  RVM  ...................................................................................................................................................................  8  Literaturempfehlungen  ....................................................................................................................................................  9   Gratis  .........................................................................................................................................................................................  9  Editoren  ...................................................................................................................................................................................  9   Editoren  ....................................................................................................................................................................................  9   IDEs  ............................................................................................................................................................................................  9  Git  Crashkurs   ....................................................................................................................  10  Standard  Workflow  .........................................................................................................................................................  10   Klonen  des  Repositories  ..................................................................................................................................................  10   Updaten  des  Repositories  ..............................................................................................................................................  10   Hinzufügen  und  Löschen  von  Dateien  ......................................................................................................................  10   ...................................................................................................................................................................................  11   Commit   Einspielen  der  Änderungen  ...........................................................................................................................................  11   Branching  .............................................................................................................................................................................  11  Literaturempfehlungen  .................................................................................................................................................  11   Gratis  ......................................................................................................................................................................................  11  Ruby  Basics  ......................................................................................................................  12  Variablen  ..............................................................................................................................................................................  12   Typisierung  ..........................................................................................................................................................................  12   Variablentypen  und  –namen  ........................................................................................................................................  12  Mathematische  Funktionen  .........................................................................................................................................  13   Standardoperationen  ......................................................................................................................................................  13   Weitere  Funktionen  .........................................................................................................................................................  13  Strings  (Zeichenketten)  .................................................................................................................................................  14   Deklaration  ..........................................................................................................................................................................  14   Informationen  über  einen  String  ...............................................................................................................................  14   Veränderung  eines  Strings  ............................................................................................................................................  15   Type  Casting  ........................................................................................................................................................................  15  Methoden  .............................................................................................................................................................................  15   Deklaration  und  Verwendung  .....................................................................................................................................  15  ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  3. 3. Query-­‐/Predicate-­‐Methoden  ........................................................................................................................................  16  Arrays  (sortierte  Listen)  ...............................................................................................................................................  16   Deklaration  ..........................................................................................................................................................................  16   Zugriff  auf  Elemente  ........................................................................................................................................................  17   Informationen  über  Arrays  ...........................................................................................................................................  17   Transformationen  .............................................................................................................................................................  17   Set-­‐Operationen  .................................................................................................................................................................  18   Queue-­‐/Stack-­‐Operationen  ...........................................................................................................................................  18   Weitere  Anwendungsfälle  .............................................................................................................................................  18   ..................................................................................................................................  18  Hashes  (Schlüssel-­‐Wert-­‐Paare)   Deklaration  ..........................................................................................................................................................................  19   Zugriff  auf  Elemente  ........................................................................................................................................................  19   Informationen  über  Hashes  ..........................................................................................................................................  19   Transformation  ..................................................................................................................................................................  20  Symbole  ................................................................................................................................................................................  20  Enumerable  .........................................................................................................................................................................  21   .............................................................................................................................................................  21   Häufige  Methoden   Minimum  und  Maximum  ................................................................................................................................................  22   Informationen  über  Enumerable  ...............................................................................................................................  22   Sortiertung  ...........................................................................................................................................................................  22   Verwendung  von  externen  Iteratoren  ......................................................................................................................  23  lambdas,  procs  und  Blöcke  ...........................................................................................................................................  23   Deklaration  und  Verwendung  .....................................................................................................................................  23   Blöcke  .....................................................................................................................................................................................  24  Kontrollstrukturen  ..........................................................................................................................................................  25   Boolsche  Operatoren  .......................................................................................................................................................  25   Conditionals  (if,  else  etc.)  ...............................................................................................................................................  25   case/when  ............................................................................................................................................................................  26   Loops  (for,  while  etc.)  ......................................................................................................................................................  27  Literaturempfehlungen  .................................................................................................................................................  27   Gratis  ......................................................................................................................................................................................  27   Kostenpflichtig  ...................................................................................................................................................................  27  Standard-­‐Library  und  Gems  ..............................................................................................  29  Standard-­‐Library  ..............................................................................................................................................................  29   Verwendung  ........................................................................................................................................................................  29   Verfügbare  Pakete  ............................................................................................................................................................  29  ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  4. 4. Status  der  Standard-­‐Library  ........................................................................................................................................  29  Gems  .......................................................................................................................................................................................  29   Verwendung  ........................................................................................................................................................................  30   Verfügbare  Pakete  ............................................................................................................................................................  30   ...............................................................................................................................................  30   Auswahl  passender  Gems   Empfohlene  Gems  ..............................................................................................................................................................  30  Bundler  .................................................................................................................................................................................  33  Literaturempfehlungen  .................................................................................................................................................  33   Gratis  ......................................................................................................................................................................................  33  Objektorientierte  Programmierung  mit  Ruby  –  Grundlagen  .............................................  34  Klassen  und  Instanzen  ...................................................................................................................................................  34  Methoden  .............................................................................................................................................................................  34   Instanzmethoden  ..............................................................................................................................................................  34   Klassenmethoden  ..............................................................................................................................................................  35   Hash-­‐Parameter  ................................................................................................................................................................  35   Multi-­‐Parameter  ................................................................................................................................................................  35  Variablen  ..............................................................................................................................................................................  36   Instanzvariablen  ...............................................................................................................................................................  36   ..............................................................................................................................................................................  36  Accessors  Access  Control  (Zugriffskontrolle)  ...........................................................................................................................  38  Vererbung  ............................................................................................................................................................................  38   Methoden  ..............................................................................................................................................................................  39   super  .......................................................................................................................................................................................  39  Literaturempfehlungen  .................................................................................................................................................  40   Gratis  ......................................................................................................................................................................................  40  Objektorientierte  Programmierung  mit  Ruby  –  Fortgeschrittene  Themen  ........................  41  Ruby  Objektmodell  ..........................................................................................................................................................  41   Klassenhierarchien  ...........................................................................................................................................................  41   Module  ...................................................................................................................................................................................  41  Methoden  .............................................................................................................................................................................  43   Messages  und  Receiver  ...................................................................................................................................................  43   self  ............................................................................................................................................................................................  44  Duck  Typing  ........................................................................................................................................................................  44  Interne  und  externe  APIs  ..............................................................................................................................................  46   ...................................................................................................................  46   Zugriff  auf  die  interne  API  mittels  send   Wann  sollte  man  send  nicht  verwenden?  ...............................................................................................................  46  ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  5. 5. Monkeypatching  ...............................................................................................................................................................  47   ActiveSupport  .....................................................................................................................................................................  47  Metaprogramming  ...........................................................................................................................................................  49   ....................................................................................................................................  49   Methoden  dynamisch  erstellen   method_missing  .................................................................................................................................................................  50   Weitere  Hooks  ....................................................................................................................................................................  53  Literaturempfehlungen  .................................................................................................................................................  53   Gratis  ......................................................................................................................................................................................  53   Kostenpflichtig  ...................................................................................................................................................................  54  Webservices  mit  Ruby  ......................................................................................................  55  REST-­‐Grundlagen  .............................................................................................................................................................  55   Gängige  Anwendungsfälle  .............................................................................................................................................  56  Sinatra  ...................................................................................................................................................................................  56   Installation  ...........................................................................................................................................................................  56   Hello  World  ..........................................................................................................................................................................  56   Beispiel:  Einfacher  Kontaktmanager  .......................................................................................................................  57   Beispiel:  Einfacher  Kontaktmanager  mit  Datenbank  .......................................................................................  58   Beispiel:  Content  Type  Negotiation  ...........................................................................................................................  61  Rails  ........................................................................................................................................................................................  62  Konsumieren  eines  REST-­‐Webservice  ....................................................................................................................  64   ActiveResource  ...................................................................................................................................................................  64   RestClient  ..............................................................................................................................................................................  65  Literaturempfehlungen  .................................................................................................................................................  66   Gratis  ......................................................................................................................................................................................  66   Kostenpflichtig  ...................................................................................................................................................................  66  Integration  Testing  mit  Cucumber  und  Capybara  ..............................................................  67  Integration  Testing  ..........................................................................................................................................................  67  Cucumber  .............................................................................................................................................................................  67   .......................................................................................................................................................................  67   Einsatzgebiet   Installation  ...........................................................................................................................................................................  68   Konfiguration  .....................................................................................................................................................................  68   Struktur  .................................................................................................................................................................................  68   Beispiel  ...................................................................................................................................................................................  69   Backgrounds  .......................................................................................................................................................................  69   ..........................................................................................................................................................  70   Ausführen  der  Tests   Implementierung  der  Schritte  .....................................................................................................................................  70  ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  6. 6. Capybara  ..............................................................................................................................................................................  70   .......................................................................................................................................................................  70   Einsatzgebiet   Installation  ...........................................................................................................................................................................  71   Konfiguration  .....................................................................................................................................................................  71   Adapter  ..................................................................................................................................................................................  71   Kommandos  .........................................................................................................................................................................  71  Literaturempfehlungen  .................................................................................................................................................  72   Gratis  ......................................................................................................................................................................................  72   Kostenpflichtig  ...................................................................................................................................................................  72  Deployment  mit  Capistrano  .............................................................................................  73  Grundlagen  ..........................................................................................................................................................................  73   Funktionsweise  ...................................................................................................................................................................  73   Voraussetzungen  ...............................................................................................................................................................  73   Setup  .......................................................................................................................................................................................  73   Anatomie  eines  Capistrano-­‐Setups  ............................................................................................................................  74   Minimalkonfiguration  .....................................................................................................................................................  74   ...........................................................................................................................................................  75  Erstes  Deployment   Vorbereitung  der  Server  ................................................................................................................................................  75   Applikationsspezifisches  Setup  ...................................................................................................................................  75   Deployment  ..........................................................................................................................................................................  76  Weiterführende  Themen  ...............................................................................................................................................  76   Definition  eigener  Tasks  ................................................................................................................................................  76   Handhabung  von  sensiblen  Daten  .............................................................................................................................  77   Persistenz  über  Deployments  .......................................................................................................................................  78  Literaturempfehlungen  .................................................................................................................................................  79   Gratis  ......................................................................................................................................................................................  79   Kostenpflichtig  ...................................................................................................................................................................  79  ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  7. 7. Installation  In  diesem  Kapitel  wird  das  Setup  einer  Ruby-­‐Entwicklungsumgebung  unter  Linux  (z.B.  Ubuntu)  beschrieben.  Vorbereitung  des  Systems  Zunächst  müssen,  sofern  nicht  bereits  vorhanden,  einige  Bibliotheken  installiert  werden:  apt-get install build-essential openssl libreadline6libreadline6-dev curl git-core zlib1g zlib1g-dev libssl-devlibyaml-dev libxml2-dev libxslt-dev autoconf libc6-devncurses-dev automake libtool bison subversionJe  nachdem,  welche  Datenbanksysteme  verwendet  werden  sollen,  müssen  auch  hierfür  noch  Bibliotheken  installiert  werden:  apt-get libsqlite3-0 libsqlite3-dev sqlite3apt-get install libmysqlclient16-devapt-get install libpq-devInstallation  von  Ruby  mittels  RVM  Der  Ruby  Version  Manager  (RVM)  wird  ist  ein  beliebtes  Werkzeug,  um  verschiedene  Versionen  von  Ruby  auf  demselben  System  zu  betreiben.  Dies  ist  beispielsweise  notwendig,  wenn  in  verschiedenen  Projekten  verschiedene  Versionen  von  Ruby  im  Einsatz  sind.  Installation  von  RVM  RVM  bietet  ein  automatisches  Installationsskript,  das  via  bash  und  curl  direkt  installiert  werden  kann:  bash < <(curl -shttps://raw.github.com/wayneeseguin/rvm/master/binscripts/rvm-installer )Außerdem  muss  RVM  in  bash_profile  geladen  werden:  echo [[ -s "$HOME/.rvm/scripts/rvm" ]] && ."$HOME/.rvm/scripts/rvm" # Load RVM function >>~/.bash_profilesource ~/.bash_profile©  2011,  Julian  Fischer  und  Clemens  Kofler  
  8. 8. Hinweis:  Bei  Verwendung  einer  anderen  Shell  muss  ggf.  eine  andere  Konfigurationsdatei  bearbeitet  werden.  Installation  von  Ruby  RVM  bietet  eine  Funktion,  die  alle  verfügbaren  Ruby-­‐Versionen  anzeigt:  rvm list knownMit  folgendem  Kommando  kann  anschließend  die  gewünschte  Version  installiert  werden  (Beispiel  1.9.3-­‐p0):  rvm install 1.9.3-p0Auswahl  der  Ruby-­‐Version  Um  eine  bestimmte  Version  von  Ruby  zu  aktivieren,  wird  rvm use  verwendet:  rvm use 1.9.3Die  gewählte  Version  gilt  nur  in  der  aktuellen  Konsolensitzung,  d.h.  alle  weiteren  Sitzungen  behalten  die  vom  System  definierte  Standardversion  von  Ruby.  Um  eine  andere  Version  als  Standards  zu  setzen,  kann  rvm use  mit  dem  Flag  --default  aufgerufen  werden:  rvm use 1.9.3 --defaultProjektspezifische  Konfiguration  RVM  unterstützt  projektspezifische  Konfigurationen.  Dazu  muss  eine  Datei  namens  .rvmrc  im  Verzeichnis  des  jeweiligen  Projekts  angelegt  werden.  Beim  Wechsel  in  dieses  Verzeichnis  führt  RVM  automatisch  diese  Datei  aus.  So  kann  z.B.  die  Ruby-­‐Version  jedes  einzelnen  Projekts  in  der  jeweiligen  .rvmrc  Datei  definiert  werden.  rvm use 1.9.3Update  von  RVM  RVM  sollte  häufig  geupdatet  werden,  um  stets  Zugriff  auf  die  neuesten  Releases  der  einzelnen  Ruby-­‐Versionen  zu  haben.  rvm get headrvm get stablervm get 1.9.2©  2011,  Julian  Fischer  und  Clemens  Kofler  
  9. 9. Literaturempfehlungen  Gratis  https://rvm.beginrescueend.com/  http://screencasts.org/episodes/how-­‐to-­‐use-­‐rvm  http://ryanbigg.com/2010/12/ubuntu-­‐ruby-­‐rvm-­‐rails-­‐and-­‐you/  Editoren  Die  meisten  gängigen  Editoren  unterstützen  Ruby  ab  Werk  oder  bieten  Erweiterungen  für  Ruby  an.  Hier  bieten  wir  eine  unvollständige  Liste  von  Editoren,  die  wir  bereits  im  Einsatz  mit  Ruby  gesehen  haben.  Editoren  TextMate:  http://macromates.com/  (Mac  OS  X)  vim:  http://www.vim.org/  emacs:  http://www.gnu.org/s/emacs/  redcar:  http://redcareditor.com/  jEdit:  http://jedit.org/  gedit  (gmate:  https://github.com/gmate/gmate)  e  Text  Editor:  http://e-­‐texteditor.com/  IDEs  RubyMine:  http://www.jetbrains.com/ruby/  RadRails:  http://aptana.com/products/radrails  Aptana  Studio:  http://aptana.com/products/studio3  NetBeans:  http://netbeans.org/  (Ruby  Plugin:  http://plugins.netbeans.org/plugin/38549/ruby-­‐and-­‐rails)    ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  10. 10. Git  Crashkurs  Git  ist  ein  mächtiges  Versionskontrollsystem.  In  diesem  Abschnitt  soll  eine  kurze  Übersicht  über  den  wichtigsten  Workflow  gegeben  werden.  Details  und  tiefer  gehende  Themen  können  im  gratis  eBook  “Pro  Git”  nachgelesen  werden.  Standard  Workflow  Klonen  des  Repositories  Das  erste  Auschecken  des  Repositories  erfolgt  mittels  git clone:  git clone git://url/pathDabei  werden  sämtliche  Daten  des  Repositories  (inkl.  Branches  und  Tags)  auf  die  locale  Maschine  kopiert.    Updaten  des  Repositories  Um  die  neuesten  Updates  aus  dem  Repository  zu  erhalten,  wird  git pull  verwendet:  git pullDabei  werden  etwaige  Änderungen  mit  lokalen  Änderungen  zusammengeführt  (merge),  wobei  es  zu  Konflikten  kommen  kann.  Häufig  können  Konflikte  vermieden  werden,  indem  git pull  mit  dem  Flag  --rebase  verwendet  wird:  git pull --rebaseHier  nimmt  Git  zunächst  alle  lokalen  Änderungen  seit  dem  letzten  Update  zurück,  spielt  das  Update  vom  Server  ein  (fast  forward)  und  fügt  anschließend  die  lokalen  Änderungen  wieder  einzeln  hinzu.  Wenn  eine  der  lokalen  Änderungen  einen  Konflikt  auslöst,  kann  dieser  behoben  werden,  was  üblicherweise  einfacher  ist,  als  alle  Konflikte  auf  einmal  zu  beheben.  Hinzufügen  und  Löschen  von  Dateien  Um  Dateien  für  den  nächsten  Commit  hinzuzufügen,  wird  git add  verwendet:  git add READMEgit  rm  wird  zum  Löschen  verwendet:  git rm README©  2011,  Julian  Fischer  und  Clemens  Kofler  
  11. 11. Commit  Im  Gegensatz  zu  anderen  Versionskontrollsystemen  wie  z.B.  Subversion  erfolgt  ein  Commit  in  Git  lokal,  d.h.  die  Änderungen  werden  nicht  sofort  am  Server  abgelegt.  Das  notwendige  Kommando  heißt  git commit  und  wird  üblicherweise  zusammen  mit  dem  Modifikator  -m  (Message)  verwendet:  git commit -m I made a changeEinspielen  der  Änderungen  Um  die  Änderungen  auf  dem  Server  einzuspielen,  wird  git push  verwendet:  git pushDieses  Kommando  funktioniert  nur,  wenn  lokal  die  aktuellste  Version  des  Servers  vorhanden  ist  –  man  sagt,  der  Branch  ist  “fast  forwardable”.  Branching  Das  Branching-­‐Modell  von  Git  ist  wohl  am  leichtesten  anhand  des  Git  Flow  Workflow  zu  verstehen.  Details  und  Illustrationen  finden  sich  im  entsprechenden  Blogpost:  http://nvie.com/posts/a-­‐successful-­‐git-­‐branching-­‐model/.  Literaturempfehlungen  Gratis  http://progit.org/  (Pro  Git;  auch  als  gedrucktes  Buch  erhältlich)  http://yehudakatz.com/2010/05/13/common-­‐git-­‐workflows/  http://nvie.com/posts/a-­‐successful-­‐git-­‐branching-­‐model/    ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  12. 12. Ruby  Basics  Variablen  Typisierung  In  Ruby  ist,  im  Gegensatz  zu  Java  und  anderen  strenger  typisierten  Sprachen,  weder  eine  Deklaration  noch  eine  Typdefintion  notwendig.  Die  Festlegung  des  Typs  erfolgt  bei  der  Initialisierung.  a = 5 # a ist nun eine Ganzzahl mit dem Wert 5s = “Hallo Welt” # s ist nun eine ZeichenketteDa  kein  Typ  festgelegt  wird,  kann  sich  der  Typ  einer  Variable  bei  Bedarf  ändern.    a = 5 # a ist nun eine Ganzzahl mit dem Wert 5a = “Hallo Welt” # a ist nun eine ZeichenketteVariablentypen  und  –namen  Ruby  unterscheidet  verschiedene  Typen  von  Variablen:   • Lokale  Variablen:  Der  Name  beginnt  mit  einem  Kleinbuchstaben.   • Globale  Variablen:  Der  Name  beginnt  mit  $.   • Konstanten:  Der  Name  beginnt  mit  einem  Großbuchstaben.   • Instanzvariablen:  Der  Name  beginnt  mit  @.   • Klassenvariablen:  Der  Name  beginnt  mit  @@.  Abgesehen  von  den  erwähnten  Regeln  überlässt  Ruby  die  Benennung  der  Variablen  dem  Programmierer.  In  der  Ruby-­‐Community  gibt  es  einige  Konventionen,  die  befolgt  werden  sollten,  um  die  Lesbarkeit  des  eigenen  Codes  für  andere  Programmierer  zu  verbessern:   • Lokale  Variablen  sowie  Instanz-­‐  und  Klassenvariablen  werden  im  snake_case   geschrieben,  d.h.  einzelne  Wörter  werden  klein  geschrieben  und  durch  einen   Unterstrich  (_)  getrennt.   • Konstanten  und  globale  Variablen  werden  im  UPPER_SNAKE_CASE  geschrieben,   d.h.  einzelne  Wörter  werden  groß  geschrieben  und  durch  einen  Unterstrich  (_)   getrennt.   • Klassennamen  bilden  einen  Sonderfall:  Obwohl  sie  streng  genommen  Konstanten   sind,  werden  sie  üblicherweise  im  CamelCase  geschrieben,  d.h.  einzelne  Wörter  ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  13. 13. werden  haben  einen  großen  Anfangsbuchstaben  und  werden  ohne  Trennzeichen   aneinander  gekettet.   • Umlaute  und  ähnliche  Sonderzeichen  sind  zwar  möglich,  sollten  aber  vermieden   werden.   • Englische  Variablennamen  werden  bevorzugt.  Mathematische  Funktionen  Rubys  mathematische  Funktionen  sind  weitgehend  ähnlich,  wie  sie  auch  in  Java,  C++  etc.  zu  finden  sind.  Standardoperationen  puts 4 + 1 # => 5puts 4 - 1 # => 3puts 4 * 2 # => 8puts 4 / 2 # => 2Wie  auch  in  anderen  Sprachen  wird  der  Typ  automatisch  auf  Fließkomma  angepasst,  wenn  ein  Operand  mit  Fließkommatyp  in  der  Berechnung  verwendet  wird:  puts 4 + 0.5 # => 4.5puts 4 * 1.5 # => 6.0puts 4 / 3 # => 1puts 4 / 3.0 # => 1.33333333333333Mathematische  Grundregeln  wie  „Punkt  vor  Strich“  werden  befolgt:  puts 4 + 2 * 3 # => 10puts (4 + 2) * 3 # => 18Weitere  Funktionen  Das  Math-­‐Modul  bietet  komplexere  mathematische  Funktionen  wie  z.B.  trigonometrische  Funktionen  (sin,  cos  etc.),  Wurzeln  (sqrt),  Logarithmen  (log,  log2,  log10,  exp)  etc.  puts Math.sqrt(9) # => 3.0puts Math.log10(100) # => 2.0Außerdem  bietet  das  Math-­‐Modul  die  Konstanten  PI  und  E.  ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  14. 14. Strings  (Zeichenketten)  Deklaration  Strings  können  in  Ruby  single-­‐  oder  double-­‐quoted  sein.  Hallo Welt # => single-quoted"Hallo Welt" # => double-quotedDie  beiden  Varianten  unterscheiden  sich  lediglich  beim  Interpolationsverhalten:  Ein  double-­‐quoted  String  kann  Variablen  interpolieren,  ein  single-­‐quoted  String  jedoch  nicht:  lang = "Java"puts "Sprache: #{lang}" # => Sprache: Javaputs Sprache: #{lang} # => Sprache: #{lang}Quotes  müssen  ggf.  escapet  werden:  puts "Ich sage: "Hallo Welt""puts Ich sage: Hallo WeltFolgende  Varianten  können  verwendet  werden,  um  auf  Escaping  zu  verzichten:  puts %(Ich sage: "Hallo Welt") # dasselbe wie %Qputs %Q(Ich sage: "Hallo Welt") # double-quotedputs %q(Ich sage: Hallo Welt) # single-quotedWeiters  kennt  Ruby  die  Heredoc-­‐Notation:  poem = <<POEMWer reitet so spät durch Nacht und Wind?Es ist der Vater mit seinem Kind.POEMputs poemHinweis:  Wenn  dem  Begrenzer  ein  -­‐  vorangestellt  wird,  kann  der  End-­‐Begrenzer  beliebig  eingerückt  werden.  Informationen  über  einen  String  lang = Javaputs lang.length # => 4puts lang.include?(e) # => falseputs lang.index(a) # => 1©  2011,  Julian  Fischer  und  Clemens  Kofler  
  15. 15. Veränderung  eines  Strings  puts lang + Script # => JavaScriptputs lang.capitalize # => Javaputs lang.downcase # => javaputs lang.upcase # => JAVAputs lang.reverse # => avaJputs lang.gsub(a, i) # => JiviBei  diesen  Operationen  wird  ein  neuer  String  erzeugt  –  der  originale  String  wird  dabei  nicht  verändert.  Es  gibt  jeweils  “destruktive”  Operationen,  die  den  originalen  String  verändern:  lang << Scriptputs lang # => JavaScriptlang.downcase!puts lang # => javascriptlang.reverse!puts lang # => tpircsavajlang.gsub!(a, i)puts lang # => tpircsivij  Type  Casting  Ein  String  kann  in  andere  Typen  umgewandelt  werden,  wenn  er  entsprechend  formatiert  ist:  puts 1.9.to_f # => 1.9puts 1.to_i # => 1puts 1.9.to_i # => 1Methoden  Methoden  werden  verwendet,  um  Funktionalität  zu  kapseln.  Deklaration  und  Verwendung  Im  Gegensatz  zu  Java  ist  es  in  Ruby  nicht  notwendig  (und  nicht  möglich),  Parameter  und  Rückgabewerte  zu  typisieren.  Wie  auch  bei  Variablen  werden  die  Typen  automatisch  festgelegt.  def multiply(a, b)©  2011,  Julian  Fischer  und  Clemens  Kofler  
  16. 16. a * bendputs multiply(4, 3) # => 12Query-­‐/Predicate-­‐Methoden  Als  Query-­‐  oder  Predicate-­‐Methoden  werden  Methoden  bezeichnet,  die  mit  einem  Fragezeichen  (?)  enden.  Diese  Methoden  geben  per  Konvention  einen  Boolean-­‐Typen  (true  oder  false)  zurück.  lang = Javaputs lang.include?(a) # => trueputs lang.include?(i) # => falseBang-­‐Methoden  Als  Bang-­‐Methoden  werden  Methoden  bezeichnet,  die  mit  einem  Rufzeichen  (!)  enden.  Die  Bang-­‐Methode  zeigt  üblicherweise  an,  dass  die  “normale”  Methode  (=  ohne  !)  mit  zusätzlichen  Effekten  ausgeführt  wird.  lang = Javalang.upcase # verändert das Original nichtputs lang # => Javalang.upcase! # verändert das Originalputs lang # => JAVA# in ActiveRecord wird versucht, eine Person anzulegenPerson.create # => im Fehlerfall wird false zurückgegebenPerson.create! # => im Fehlerfall wird eine Exception geworfenArrays  (sortierte  Listen)  Ararys  sind  sortierte  Listen  von  Elementen.  Deklaration  Arrays  werden  mit  einer  Literal-­‐Syntax  deklariert.  Die  Größe  des  Arrays  wird  automatisch  bestimmt  und  erweitert  und  muss  daher  nicht  explizit  angegeben  werden.  numbers = [1, 3, 3, 7]p numbers # => [1, 3, 3, 7]languages = [Java, Ruby]©  2011,  Julian  Fischer  und  Clemens  Kofler  
  17. 17. p languages # => ["Java", "Ruby"]Aufgrund  der  dynamischen  Typisierung  kann  ein  Array  in  Ruby  Elemente  beliebiger  verschiedener  Typen  enthalten  (vgl.  untypisierte  ArrayList  in  Java).  mixed = [1, Java, 2, Ruby]p mixed # => [1, "Java", 2, "Ruby"]String  Arrays  können  mit  einer  alternativen  Literal-­‐Syntax  deklariert  werden:  languages = %w(Java Ruby)p languages # => ["Java", "Ruby"]script = Scriptlanguages = %W(Java#{script} Ruby)p languages # => ["JavaScript", "Ruby"]Zugriff  auf  Elemente  Arrays  sind  mit  Ganzzahlen  indexiert.  Die  Indexierung  beginnt  wie  in  vielen  anderen  Sprachen  mit  0.  Der  Zugriff  auf  ein  nicht  existierendes  Element  gibt  nil  zurück.  Ein  negativer  Index  beginnt  vom  Ende  des  Arrays.  languages = [Java, Ruby]p languages[1] # => "Ruby"p languages[2] # => nilp languages[-1] # => "Ruby"Das  Schreiben  von  Werten  funktioniert  ähnlich:  languages[0] = JavaScriptp languages # => ["JavaScript", "Ruby"]languages[2] = C#p languages # => ["JavaScript", "Ruby", "C#"]Informationen  über  Arrays  languages = [Java, Ruby, C#]puts languages.length # => 3puts languages.empty? # => falseputs languages.index(C#) # => 1Transformationen  p [[Java, C#], [Ruby, JavaScript]].flatten# => ["Java", "C#", "Ruby", "JavaScript"]©  2011,  Julian  Fischer  und  Clemens  Kofler  
  18. 18. puts [Java, C#, Ruby, JavaScript].join(, )# => Java, C#, Ruby, JavaScriptp ["Java", "Ruby", "Java"].uniq # => ["Java", "Ruby"]Set-­‐Operationen  Arrays  in  Ruby  unterstützen  gängige  Set-­‐Operationen  wie  Schnitt  (intersect),  Vereinigung  (union),  Ausschuss  (diff)  und  Addition.  p ["Java", "Ruby"] & ["Ruby", "JavaScript"]# => ["Ruby"]p ["Java", "Ruby"] | ["Ruby", "JavaScript"]# => ["Java", "Ruby", "JavaScript"]p ["Java", "Ruby"] + ["Ruby", "JavaScript"]# => ["Java", "Ruby", "Ruby", "JavaScript"]p ["Java", "Ruby"] - ["Java", "JavaScript"]# => ["Ruby"]Queue-­‐/Stack-­‐Operationen  Arrays  können  wie  Queues/Stacks  verwendet  werden.  languages = [Ruby]languages.unshift(Java)p languages # => ["Java", "Ruby"]languages.push(C#)p languages # => ["Java", "Ruby", "C#"]puts languages.shift # => Javap languages # => ["Ruby", "C#"]puts languages.pop # => C#p languages # => ["Ruby"]Weitere  Anwendungsfälle  Für  weitere  Anwendungsfälle  bietet  die  Ruby  Standard  Library  die  Klassen  Set  und  SortedSet,  die  jeweils  Duplikate  verhindert.  Hashes  (Schlüssel-­‐Wert-­‐Paare)  Hashes  sind  Schlüssel-­‐Wert-­‐Paare.  Sie  werden  besonders  gern  für  Parameterlisten  verwendet,  wo  die  Reihenfolge  der  Parameter  keine  Rolle  spielt.  ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  19. 19. Deklaration  Hashes  werden  mit  einer  Literal-­‐Syntax  deklariert.  hash = { a => 100, b => 50, c => 10 }p hash # => {"a"=>100, "b"=>50, "c"=>10}Aufgrund  der  dynamischen  Typisierung  kann  ein  Array  in  Ruby  Elemente  beliebiger  verschiedener  Typen  enthalten.  hash = { a => 100, b => Hallo Welt }p hash # => {"a"=>100, "b"=>"Hallo Welt"}Obwohl  theoretisch  jedes  Objekt  als  Key  verwendet  werden  kann,  werden  in  der  Regel  Strings  oder  Symbole  (mehr  dazu  später)  verwendet.  Hashes  können  auch  direkt  aus  Name-­‐Wert-­‐Paaren  erzeugt  werden:  p Hash[a, 100, b, 50] # => {"a"=>100, "b"=>50}p Hash[[[a, 100], [b, 50]]] # => {"a"=>100, "b"=>50}Zugriff  auf  Elemente  Der  Zugriff  auf  Hash-­‐Elemente  erfolgt  auf  dieselbe  Art  wie  bei  Arrays:  hash = { a => 100, b => 50, c => 10 }puts hash[a] # => 100Es  können  auch  mehrere  Werte  auf  einmal  ausgelesen  werden:  p hash.values_at(c, a) # => [10, 200]Ein  Ausschnitt  eines  Hashes  kann  wie  folgt  erzeugt  werden:  p hash.slice (a, c) # => {"a"=>100, "c"=>10}Wie  bei  Arrays  erzeugt  ein  Zugriff  auf  ein  nicht  existierendes  Element  keinen  Fehler,  sondern  gibt  nil  zurück.  puts hash[d] # => nilDas  Setzen  eines  Wertes  erfolgt  ebenfalls  auf  dieselbe  Art  wie  bei  Arrays:  hash[a] = 200puts hash[a] # => 200Informationen  über  Hashes  p hash.keys # => ["a", "b", "c"]puts hash.size # => 3©  2011,  Julian  Fischer  und  Clemens  Kofler  
  20. 20. puts hash.empty? # => falseputs hash.has_key?(b) # => trueputs hash.has_value?(500) # => falseTransformation  p hash.invert # => {50=>"b", 200=>"a", 10=>"c"}p hash.to_a # => [["a", 200], ["b", 50], ["c", 10]]puts hash.delete(a) # => 200p hash # => {"b"=>50, "c"=>10}p hash.merge(a => 50) # => {"a"=>50, "b"=>50, "c"=>10}p hash # => {"b"=>50, "c"=>10}Hinweis:  merge  verändert  den  originalen  Hash  nicht.  Um  den  originalen  Hash  direkt  zu  verändern,  kann  die  Bang-­‐Variante  (merge!)  verwendet  werden.  Symbole  Symbole  sind  benannte  Literale,  die  an  einer  speziellen  Stelle  im  Speicher,  der  so  genannten  symbol  table,  abgelegt  sind.  Sie  sind  durch  einen  führenden  Doppelpunkt  (:)  gekennzeichnet.  Im  Gegensatz  zu  Strings  behält  ein  Symbol  stets  seine  Speicheradresse  und  ist  daher  immer  “identisch”.  puts Test.object_id # => 2152459300puts Test.object_id # => 2152449720puts :test.object_id # => 144328puts :test.object_id # => 144328Verwendung  von  Symbolen  Symbole  werden  hauptsächlich  als  Keys  für  Hashes  verwendet:  hash = { :a => 1, :b => 2 }puts hash[:a] # => 1Außerdem  dienen  sie  häufig  als  Ersatz  für  (Integer-­‐)Konstanten.  NORTH = 1EAST = 2SOUTH = 3©  2011,  Julian  Fischer  und  Clemens  Kofler  
  21. 21. WEST = 4def move(direction) if direction == NORTH moveNorth # ... endendmove(NORTH)Dieser  Code  wird  in  Ruby  tendenziell  so  geschrieben:  def move(direction) if direction == :north moveNorth # ... endendmove(:north)Enumerable  Enumerable  ist  ein  Modul  bzw.  Mixin  (vgl.  Interface  in  Java),  das  verschiedene  Iterator-­‐Methoden  zur  Verfügung  stellt.  Jede  Klasse,  die  “enumerable”  sein  will,  muss  eine  Methode  Names  each  bereitstellen.  Die  Klassen  Array  und  Hash  verwenden  Enumerable:  numbers = [50, 40, 30, 20, 10]numbers.each { |n| puts n }hash = { a => 100, b => 50, c => 10 }hash.each { |key, value| puts "#{key}: #{value}" }numbers.each_with_index { |n, i| puts "#{i}: #{n}" }Häufige  Methoden   • map  (Alias:  collect):  wendet  den  übergebenen  Block  auf  jedes  Element  an   • select  (Alias:  find_all):  selektiert  alle  Elemente,  für  die  der  übergebene   Block  true  zurück  gibt  ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  22. 22. • reject:  selektiert  alle  Elemente,  für  die  der  übergebene  Block  false  zurück   gibt   • detect  (Alias:  find):  gibt  das  erste  Element  zurück,  für  das  der  übergebene   Block  true  zurück  gibt  (nil,  wenn  keines  gefunden  wird)  p numbers.map { |n| n * 2 } # => [100, 80, 60, 40, 20]p numbers.select { |n| n < 25 } # => [20, 10]p numbers.reject { |n| n < 25 } # => [50, 40, 20]puts numbers.detect { |n| n < 25 } # => 20Minimum  und  Maximum  numbers = [50, 40, 30, 20, 10]puts numbers.min # => 10puts numbers.max # => 50p numbers.minmax # => [10, 50]languages = [Java, Ruby, C#]puts languages.max # => Rubyputs languages.min { |l1, l2| l1.length <=> l2.length } # =>C#puts languages.min_by { |language| language.length } # => C#Informationen  über  Enumerable  p numbers.any? { |n| n > 100 } # => falsep numbers.none? { |n| n > 100 } # => truep numbers.all? { |n| n < 100 } # => truep numbers.one? { |n| n >= 50 } # => trueSortiertung  Auch  Sortierung  ist  Teil  des  Enumerable  Mixins.  p numbers.sort# => [10, 20, 30, 40, 50]p hash.sort_by { |k, v| v }# => [["c", 10], ["b", 50], ["a", 100]]Hinweis:  Beide  Sortierungsfunktionen  verändern  das  originale  Objekt  nicht.  Wenn  das  originale  Objekt  direkt  sortiert  werden  soll,  gibt  es  jeweils  destruktive  Bang-­‐Methoden  dafür  (sort!  bzw.  sort_by!).  ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  23. 23. Verwendung  von  externen  Iteratoren  Es  ist  möglich,  eigenständige  (externe)  Iterator-­‐Objekte  zu  verwenden,  die  ähnlich  wie  Iteratoren  in  Java  funktionieren.  Dazu  wird  der  gewünschte  Iterator  ohne  Block  aufgerufen.  enumerator = [1, 2, 3].eachputs enumerator.next # => 1Diese  Variante  wird  jedoch  eher  selten  verwendet.  lambdas,  procs  und  Blöcke  lambdas  und  procs  sind  Blöcke  von  Code,  die  als  Objekte  durchgereicht  und  dynamisch  ausgeführt  werden  können.  Am  ehesten  sind  sie  mit  Callback-­‐Funktionen  in  JavaScript  und  anonymen  inneren  Klassen  in  Java  (z.B.  ActionListener)  zu  vergleichen.  Deklaration  und  Verwendung  greeter = proc { |name| "Hallo #{name}" }puts greeter.call("Matz") # => "Hallo Matz"Wie  bereits  erwähnt,  sind  procs  Objekte  und  können  z.B.  als  Parameter  an  Methoden  übergeben  und  dort  mittels  call  aufgerufen  werden:  def output_greeting(greeter_proc, name) puts greeter_proc.call(name)endoutput_greeting(greeter, "Matz") # => "Hallo Matz"lambdas  unterscheiden  sich  von  procs  dadurch,  dass  die  Parameter  eines  lambda  verpflichtend  sind:  a_proc = proc { |a| puts "a: #{a}" }a_proc.call(1) # => a: 1a_proc.call(1, 2) # => a: 1a_proc.call # => a:a_lambda = lambda { |a| puts "a: #{a}" }a_lambda.call(1) # => a: 1a_lambda.call(1, 2)# => wrong number of arguments (2 for 1) (ArgumentError)a_lambda.call©  2011,  Julian  Fischer  und  Clemens  Kofler  
  24. 24. # => wrong number of arguments (0 for 1) (ArgumentError)Blöcke  Methoden  können  optional  einen  Parameter  als  so  genannten  Block  entgegen  nehmen.  Ein  Beispiel  sind  Iteratoren.  numbers = [1, 2, 3]numbers.each { |n| puts n }Der  Abschnitt    { |n| puts n }  wird  dabei  als  Block  bezeichnet  und  wird  für  jedes  Element  des  Arrays  aufgerufen.  Weitere  Beispiele:  # ohne Blockf = File.open(/Users/clemenskofler/test.txt)puts f.readf.close# mit Block: Ruby öffnet die Datei, lässt uns damit arbeitenund kümmert sich automatisch um das Schließen der DateiFile.open(/Users/clemenskofler/test.txt) { |f| puts f.read }Man  kann  auch  selbst  Methoden  mit  Block-­‐Parametern  definieren.  def handle_file(file, &block) f = File.open(file) block.call(f) f.closeendfile = /Users/clemenskofler/test.txthandle_file(file) { |f| puts f.read }Statt  den  Block  direkt  mit  call  aufzurufen,  kann  auch  yield  verwendet  werden.  Dabei  kann  auf  die  explizite  Deklaration  des  Block-­‐Parameters  verzichtet  werden.  def handle_file(file) f = File.open(file) yield(f) f.closeendfile = /Users/clemenskofler/test.txthandle_file(file) { |f| puts f.read }©  2011,  Julian  Fischer  und  Clemens  Kofler  
  25. 25.  Kontrollstrukturen  Ruby  kennt  ähnliche  Kontrollstrukturen  wie  Java,  um  den  Fluss  des  Programms  zu  steuern.  Boolsche  Operatoren  Ruby  kennt  dieselben  boolschen  Operatoren  wie  Java:   • &&,  and:  logisches  Und   • ||,  or:  logisches  Oder   • !,  not:  logisches  Nicht   • <,  <=,  >,  >=:  kleiner/größer  (gleich)   • ==:  gleich  Die  Operatoren  folgen  den  üblichen  Regeln  der  boolschen  Algebra.  Allerdings  kann  im  Gegensatz  zu  anderen  Sprachen  nicht  nur  ein  boolscher  Wert  sondern  jeder  beliebige  Wert  an  einem  boolschen  Ausdruck  teilnehmen.  In  Ruby  evaluiert  in  einem  boolschen  Ausdruck  jeder  Wert  außer  false  und  nil  auf  true.  Conditionals  (if,  else  etc.)  today = Time.nowif today.wday == 6 puts "Hausarbeit!"elsif today.wday == 7 puts "Relax"else puts "Arbeit"endWie  bei  anderen  Programmiersprachen  sind  die  Abschnitte  elsif  und  else  optional.  Außerdem  kann  bei  negierten  Bedingungen  unless  verwendet  werden:  x = 41if x != 42 puts "Die Antwort ist 42, nicht #{x}!”end©  2011,  Julian  Fischer  und  Clemens  Kofler  
  26. 26. unless x == 42 puts "Die Antwort ist 42, nicht #{x}!”endHinweis:  unless  +  else  sollte  der  Klarheit  wegen  vermieden  werden.  Als  Kurzform  für  if/else  kann  der  ternäre  Operator  verwendet  werden:  d = today.wdayif d == 6 || d == 7 puts "Wochenende"else puts "Noch nicht Wochenende"endputs d == 6 || d == 7 ? "Wochenende" : "Noch nicht Wochenende"Im  Gegensatz  zu  anderen  Sprachen  hat  in  Ruby  auch  ein  if/else-­‐Konstrukt  einen  Rückgabewert:  d = today.wdayoutput = if d == 6 || d == 7 "Wochenende"else "Noch nicht Wochenende"endputs outputFür  einzelne  if/unless-­‐Konstrukte  wird  gerne  die  Inline-­‐Variante  verwendet,  wo  die  Bedingung  nachgestellt  wird:  puts "Mach irgendwas Sinnvolles" if today.wday == 6puts "Noch immer nicht Sonntag" unless today.wday == 7case/when  Ein  case-­‐when-­‐Ausdruck  ist  das  Ruby-­‐Pendant  zum  aus  Java  bekannten  switch-­‐case.  case today.wday©  2011,  Julian  Fischer  und  Clemens  Kofler  
  27. 27. when 7 puts "Sonntag"when 6 puts "Samstag"else puts "Immer noch nicht Wochenende :("endFür  kurze  Abschnitte  gibt  es  auch  hier  eine  Inline-­‐Variante:  case today.wdaywhen 7 then puts "Sonntag"when 6 then puts "Samstag"else puts "Immer noch nicht Wochenende :("endEs  können  auch  mehrere  Werte  in  einem  when  verwendet  werden:  case today.wdaywhen 6, 7 then puts "Wochenende"else puts "Immer noch nicht Wochenende :("endKomplexere  case-­‐when-­‐Varianten  werden  später  behandelt.  Loops  (for,  while  etc.)  Ruby  kennt  verschiedene  Schleifen:  for,  while,  do ... while  und  until.  Diese  funktionieren  im  Wesentlichen  gleich  wie  in  Java.  In  den  meisten  Fällen  werden  jedoch  Iteratoren  (z.B.  each)  vorgezogen,  weil  sie  einfacher  zu  handhaben  sind.  Literaturempfehlungen  Gratis  http://mislav.uniqpath.com/poignant-­‐guide/book/  (Kapitel  3+4)  http://ruby-­‐doc.org/docs/  (allerlei  Links  zu  Dokumentationen)  http://ruby-­‐doc.org/docs/ProgrammingRuby/  (ältere  Version  von  Programming  Ruby)  Kostenpflichtig  http://www.amazon.de/dp/0596516177  (The  Ruby  Programming  Language)  ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  28. 28. http://www.amazon.de/dp/1430223634  (Beginning  Ruby)  ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  29. 29. Standard-­‐Library  und  Gems  Ruby  unterteilt  sich  in  eine  Core-­‐  und  Standard-­‐Library:  Während  die  Core-­‐Library  automatisch  zur  Verfügung  steht,  müssen  Elemente  der  Standard-­‐Library  vor  Verwendung  explizit  mittels  require  geladen  werden.  Zusätzlich  liefert  Ruby  seit  Version  1.9  den  Paketmanager  RubyGems  aus  (in  älteren  Ruby-­‐Versionen  wurde  dieser  in  der  Regel  manuell  dazu  installiert).  Ein  Gem  ist  ein  Programmpaket,  das  eigenständig  ausgeliefert  und  von  Anwendungen  verwendet  werden  kann.  Standard-­‐Library  Verwendung  Pakete  der  Standard-­‐Library  können  mittels  require  geladen  und  anschließend  verwendet  werden.  require dateputs Date.today # => 2011-12-15Dasselbe  Paket  kann  ohne  weiteres  mehrmals  mittels  require  eingebunden  werden:  Tatsächlich  ignoriert  Ruby  mehrfache  Aufrufe.  Verfügbare  Pakete  Eine  Liste  aller  verfügbaren  Pakete  für  die  aktuelle  Ruby-­‐Version  (aktuell:  1.9.3)  findet  sich  stets  unter  http://www.ruby-­‐doc.org/stdlib.  Status  der  Standard-­‐Library  Viele  Pakete  der  Standard-­‐Library  sind  veraltet  und/oder  schlecht  gewartet.  Viele  Ruby-­‐Programmierer  haben  daher  Gems  geschrieben,  die  weniger  geeignete  Pakete  der  Standard-­‐Library  ersetzen  sollen.  Je  nach  Themenbereich  können  alternative  Lösungen  auf  Ruby  Toolbox  (https://www.ruby-­‐toolbox.com/)  und  RubyGems.org  (https://rubygems.org/)  recherchiert  werden.  Gems  Gems  sind  Programmpakete,  die  mithilfe  des  Paketmanagers  RubyGems  installiert  werden  und  anschließend  in  der  Applikation  verwendet  werden  können.  ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  30. 30. Verwendung  Gems  können  entweder  direkt  über  RubyGems  oder  mit  Bundler  verwendet  werden.  require rubygemsrequire activesupportputs .blank? # => trueVerfügbare  Pakete  Gems  werden  grundsätzlich  auf  https://rubygems.org/  gehostet,  wo  alle  Informationen  (z.B.  Versionen,  Paketabhängigkeiten  etc.)  einsehbar  sind.  Eine  strukturiertere  Auflistung  vieler  Gems  findet  sich  auf  https://www.ruby-­‐toolbox.com/.  Auswahl  passender  Gems  Gems  unterliegen  grundsätzlich  keiner  Qualitätskontrolle,  d.h.  die  Auswahl  geeigneter  Gems  mit  guter  Qualität  obliegt  dem  Programmierer.  Mit  Hilfe  von  Ruby  Toolbox  (https://www.ruby-­‐toolbox.com/)  lässt  sich  anhand  einiger  Kriterien  mit  großer  Wahrscheinlichkeit  feststellen,  ob  das  Gem  von  guter  Qualität  ist:   • Hat  das  Gem  eine  verständliche  und  ausführliche  Readme?   • Hat  das  Gem  eine  automatische  Test-­‐Suite?   • Ist  das  Gem  von  einem  angesehen  Autor?   • Wird  das  Gem  aktiv  gewartet?   • Wie  lange  gibt  es  das  Gem  bereits?   • Wird  das  Gem  von  vielen  Leuten  verwendet  (häufig  gedownloadet)?   • Wird  das  Gem  auf  GitHub  (de-­‐facto-­‐Standard)  gehostet?   • Hat  das  Gem  viele  offene  Bugmeldungen  auf  GitHub?  Empfohlene  Gems  Im  Folgenden  sind  einige  gängige  Anwendungsfälle  sowie  passende,  häufig  verwendete  Gems  zusammengetragen.    File  Uploads  (+  Image  Processing)   • Carrierwave   • Paperclip  User  Authentifizierung  und  Autorisierung  ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  31. 31. • Devise   • Sorcery   • OmniAuth  (externe  Auth  Provider,  z.B.  Facebook)   • CanCan  Formulare   • Formtastic   • SimpleForm  Permalinks   • friendly_id  XML   • hpricot  (simpel)   • Nokogiri  (komplexer)  SOAP   • handsoap   • savon  HTTP   • httparty   • faraday   • curb  Payment   • activemerchant  Tagging   • acts_as_taggable_on  Testing   • rspec   • Capybara  (+  Cucumber)   • capybara_webkit   • FactoryGirl   • DatabaseCleaner   • Timecop   • FakeWeb   • vcr   • Faker  ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  32. 32. Automatisierung   • guard   • foreman  Internationalisierung   • i18n   • globalize  State  Machine   • AASM  (Acts  As  State  Machine)  Paginierung   • will_paginate   • kaminari  Deployment   • Capistrano   • Vlad  Monitoring   • Exceptional   • Airbrake   • NewRelic   • Scout  (Lokaler)  Webserver   • Mongrel   • pow   • unicorn   • thin  Log  Analyse   • request-­‐log-­‐analyzer  Code  Qualität   • SimpleCov  /  rcov   • metric_fu  (+  darin  enthaltene  Gems)    ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  33. 33. Bundler  Bundler  wird  verwendet,  um  Abhängigkeiten  unter  verschiedenen  Gems  zu  verwalten  und  aufzulösen.  Bevor  Bundler  verwendet  wurde,  gab  es  häufig  Versionskonflikte,  weil  der  RubyGems  Paketmanager  lediglich  einen  unzureichenden  Algorithmus  zur  Auflösung  von  Paketabhängigkeiten  bereitstellt.  Wir  halten  an  dieser  Stelle  eine  dedizierte  Einführung  in  Bundler  nicht  für  sinnvoll,  weil  die  Problematik,  die  Bundler  löst,  sich  erst  in  der  tatsächlichen  Entwicklung  mit  Ruby  erschließt.  Dennoch  wollten  wir  den  Dependency  Manager  an  dieser  Stelle  erwähnen,  damit  zumindest  der  Begriff  bekannt  ist.  Literaturempfehlungen  Gratis  http://www.mikeperham.com/2010/11/22/the-­‐ruby-­‐stdlib-­‐is-­‐a-­‐ghetto/  https://www.ruby-­‐toolbox.com/  https://rubygems.org/  http://gembundler.com/  http://railscasts.com/episodes/201-­‐bundler  ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  34. 34. Objektorientierte  Programmierung  mit  Ruby  –  Grundlagen  Klassen  und  Instanzen  Ruby  ist  –  wie  Java  –  eine  klassenbasierte  objektorientierte  Sprache.  Klassen  werden  definiert  und  dienen  als  Vorlage  für  konkrete  Objektinstanzen.  class PersonendNeue  Instanzen  werden  erzeugt,  indem  die  Methode  new  auf  die  Klasse  aufgerufen  wird.  matz = Person.newp matz # => #<Person:0x100139b50>Methoden  Methoden  definieren  die  Funktionalitäten  von  Klassen  und  Objekten.  Man  unterscheidet  zwischen  Klassen-­‐  und  Instanzmethoden.  Instanzmethoden  Instanzmethoden  sind  Methoden,  die  innerhalb  einer  Instanz  zur  Verfügung  stehen.  class Person def says_hello puts Hello! endendmatz = Person.newmatz.says_helloDie  Methode  initialize  ist  ein  Spezialfall  einer  Instanzmethode  und  dient  als  Konstruktor.  Hier  wird  die  Objektinstanz  für  die  Verwendung  vorbereitet.  class Person def initialize puts in initialize endend©  2011,  Julian  Fischer  und  Clemens  Kofler  
  35. 35. matz = Person.newKlassenmethoden  Klassenmethoden  sind  Methoden,  die  für  eine  Klasse  zur  Verfügung  stehen.  class Person def self.test puts Person.test endendPerson.testHash-­‐Parameter  Häufig  wird  in  Ruby  ein  Hash  als  letzter  Parameter  einer  Methode  verwendet.  Besonders  bei  Ruby  on  Rails  nennt  man  diesen  gern  “options  hash”.  def content_tag(name, content, options = {}) html = "<#{name}" options.each do |key, value| html << %( #{key}="#{value}") end html << ">#{content}</#{name}>" htmlendputs content_tag(:p, Hello, { :class => greeting })# => <p class="greeting">Hello</p>Wenn,  wie  in  diesem  Fall,  der  Hash  der  letzte  Parameter  des  Methodenaufrufs  ist,  werden  die  geschwungenen  Klammern  üblicherweise  weggelassen:  puts content_tag(:p, Hello, :class => greeting)# => <p class="greeting">Hello</p>Multi-­‐Parameter  In  Ruby  ist  es  möglich,  mehrere  Parameter  zu  übergeben,  und  diese  in  einem  Array  statt  als  einzelne  Parameter  engegenzunehmen.  def values_in_hash(hash, *fields) fields.map { |field| hash[field] }©  2011,  Julian  Fischer  und  Clemens  Kofler  
  36. 36. endhash = { :a => 1, :b => 2, :c => 3, :d => 4 }p values_in_hash(hash, :a, :c) # => [1, 3]Auch  der  umgekehrte  Weg  ist  möglich:  Man  kann  die  Werte  in  einem  Array  als  mehrere  Einzelparameter  übergeben:  hash = { :a => 1, :b => 2, :c => 3, :d => 4 }fields = [:a, :c]p hash.values_at(*fields) # => [1, 3]Wenn  der  *  Operator  einem  Array  vorangestellt  wird,  nennt  man  ihn  “Splat”.  Variablen  Wie  bereits  zu  Anfang  erwähnt,  unterscheidet  Ruby  zwischen  Instanz-­‐  (beginnen  mit  @)  und  Klassenvariablen  (beginnen  mit  @@).  Instanzvariablen  Instanzvariablen  stehen  innerhalb  einer  Instanz  zur  Verfügung.  class Person def initialize(name) @name = name end def says_hello puts "Hello from #{@name}!" endendmatz = Person.new(Matz)matz.says_helloAccessors  Ruby  verwendet  einen  Accessor-­‐/Property-­‐basierten  Ansatz,  um  Instanzvariablen  nach  außen  zur  Verfügung  zu  stellen.  class Person attr_accessor :name©  2011,  Julian  Fischer  und  Clemens  Kofler  
  37. 37. # attr_reader :name # attr_writer :nameendmatz = Person.newmatz.name = Matzputs matz.name# ohne Accessorclass Person def name @name end def name=(new_name) @name = new_name endendmatz = Person.newmatz.name = Matzputs matz.nameEin  Accessor  greift  dabei  immer  auf  die  Instanzvariable  mit  demselbem  Namen  zu.  class Person attr_accessor :name def initialize(name) @name = name endendmatz = Person.new(Matz)puts matz.namematz.name = Yukihiro Matsumotoputs matz.name©  2011,  Julian  Fischer  und  Clemens  Kofler  
  38. 38. Access  Control  (Zugriffskontrolle)  Methoden  können  vor  dem  Zugriff  geschützt  werden.  Dafür  stehen  die  Deklarationen  protected  und  private  zur  Verfügung.  Ohne  explizite  Deklaration  sind  alle  Methoden  public.  class Person def dont_call_me puts "Dont call me!" end private :dont_call_meendPerson.new.dont_call_me # => NoMethodError: private method‘dont_call_me’ called for #<Person:0x1001352f8>Es  ist  auch  möglich,  mehrere  Methoden  auf  einmal  als  public/protected/private  zu  deklarieren:  class Person public # ... everythings public from now on protected # ... now protected private # ... now private public # ... and public againendHinweis:  protected  und  private  unterscheiden  sich  marginal  und  können  in  der  Regel  synonym  betrachtet  werden.  Vererbung  Jede  Klasse  in  Ruby  kann  von  einer  anderen  Klasse,  der  so  genannten  Superklasse,  erben.  Wenn  eine  Klasse  keine  Superklasse  hat,  erbt  sie  von  Object  (wie  in  Java).  Der  Vererbungsoperator  ist  <.  class Personend©  2011,  Julian  Fischer  und  Clemens  Kofler  
  39. 39. class Programmer < PersonendMethoden  Klassen  erben  alle  Methoden  ihrer  Superklasse.  class Person def initialize(name) @name = name end def about_me @name endendclass Programmer < Personendmatz = Programmer.new(Matz)puts matz.about_meKlassenmethoden  und  Accessors  werden  ebenso  wie  Instanzmethoden  geerbt.  super  Klassen  können  Methoden  ihrer  Superklasse  überschreiben  und  die  originale  Methode  bei  Bedarf  mit  super  aufrufen.  class Person def initialize(name) @name = name end def about_me @name endend©  2011,  Julian  Fischer  und  Clemens  Kofler  
  40. 40. class Programmer < Person def about_me "#{super} (Programmer)" endendmatz = Programmer.new(Matz)puts matz.about_meLiteraturempfehlungen  Gratis  http://langref.org/ruby/oop  http://zetcode.com/lang/rubytutorial/oop/  http://bandwagonblog.wordpress.com/2009/01/12/ruby-­‐oop-­‐intro/  ©  2011,  Julian  Fischer  und  Clemens  Kofler  
  41. 41. Objektorientierte  Programmierung  mit  Ruby  –  Fortgeschrittene  Themen  Ruby  Objektmodell  Alles  in  Ruby  ist  ein  Objekt  –  selbst  die  vermeintlich  “primitiven  Datentypen”  wie  Zahlen.  Die  Klasse  jedes  Objekts  kann  mit  .class  überprüft  werden:  puts 1.class # => Fixnumputs 1.5.class # => Floatputs a.class # => Stringputs [].class # => Arrayputs ({}).class # => HashSelbst  Klassen  sind  Objekte  –  und  zwar  vom  Typ  Class.  puts Array.class # => Classputs Hash.class # => ClassKlassenhierarchien  Die  Hierarchie  einer  Klasse  kann  mit  der  Methode  superclass  geprüft  werden.  puts Array.superclass # => Objectputs Object.superclass # => BasicObjectputs BasicObject.superclass # => nilAlle  inkludierten  Module  und  Superklassen  sind  mit  der  Methode  ancestors  einsehbar.  p Array.ancestors# => [Array, Enumerable, Object, Kernel, BasicObject]Module  Ruby  Module  sind  am  ehesten  mit  Java  Interfaces  zu  vergleichen.  Der  wesentliche  Unterschied  besteht  darin,  dass  Ruby  Module  in  der  Regel  nicht  nur  ein  Interface  zur  Verfügung  stellen,  sondern  auch  eine  Implementierung.  module Naming def full_name "#{first_name} #{last_name}" end©  2011,  Julian  Fischer  und  Clemens  Kofler  
  42. 42. endclass Person attr_reader :first_name, :last_name include Naming def initialize(first_name, last_name) @first_name = first_name @last_name = last_name endendmatz = Person.new(Yukihiro, Matsumoto)puts matz.full_name # => Yukihiro MatsumotoPerson  inkludiert  das  Modul  Naming.  Dadurch  wird  implizit  ein  Vertrag  geschlossen,  in  dem  Person  garantiert,  die  Methoden  first_name  und  last_name,  die  von  Naming  benötigt  werden,  zur  Verfügung  zu  stellen.  Wir  haben  einen  derartigen  Vertrag  bereits  beim  Modul  Enumerable  gesehen:  Jede  Klasse,  die  Enumerable  verwenden  will,  garantiert,  dass  seine  Methode  each  zur  Verfügung  gestellt  wird,  auf  der  die  restlichen  Iteratoren  aufsetzen.  So  kann  eine  jede  Klasse  iterierbar  gemacht  werden.  class PersonRepository include Enumerable def initialize(people) @people = people end def each(&block) @people.each { |person| block.call(person) } endendclass Person©  2011,  Julian  Fischer  und  Clemens  Kofler  
  43. 43. attr_reader :name def initialize(name) @name = name end def inspect name endendpeople = [Person.new(Matz), Person.new(Clemens),Person.new(Julian)]person_repository = PersonRepository.new(people)p person_repository.collect { |person| person.name }# => ["Matz", "Clemens", "Julian"]p person_repository.sort_by { |person| person.name }# => [Clemens, Julian, Matz]Methoden  Zum  Verständnis  von  Rubys  Objektmodell  ist  es  essentiell,  zu  verstehen,  wie  Methoden  aufgerufen  werden.  Messages  und  Receiver  Wenn  man  in  Ruby  vom  Aufruf  einer  Methode  spricht,  meint  man  streng  genommen,  dass  eine  Message  (Nachricht)  mit  einem  bestimmten  Namen  an  ein  Objekt  –  den  so  genannten  Receiver  (Empfänger)  gesendet  wird:  name = "Matz"puts name.lengthIn  diesem  Beispiel  wird  eine  Message  mit  dem  Namen  length  an  das  Objekt  name  gesendet.  Das  Objekt  name  ist  somit  der  Receiver  der  Message  length.  ©  2011,  Julian  Fischer  und  Clemens  Kofler  

×