diff options
Diffstat (limited to 'de-de/ruby-de.html.markdown')
| -rw-r--r-- | de-de/ruby-de.html.markdown | 782 |
1 files changed, 429 insertions, 353 deletions
diff --git a/de-de/ruby-de.html.markdown b/de-de/ruby-de.html.markdown index e14603cd..8025a8c0 100644 --- a/de-de/ruby-de.html.markdown +++ b/de-de/ruby-de.html.markdown @@ -1,5 +1,6 @@ --- language: ruby +filename: ruby-de.rb contributors: - ["David Underwood", "http://theflyingdeveloper.com"] - ["Joel Walden", "http://joelwalden.net"] @@ -11,602 +12,677 @@ contributors: - ["Dzianis Dashkevich", "https://github.com/dskecse"] - ["Levi Bostian", "https://github.com/levibostian"] - ["Rahil Momin", "https://github.com/iamrahil"] + - ["Gabriel Halley", "https://github.com/ghalley"] + - ["Persa Zula", "http://persazula.com"] + - ["Jake Faris", "https://github.com/farisj"] + - ["Corey Ward", "https://github.com/coreyward"] + - ["Jannik Siebert", "https://github.com/janniks"] + - ["Keith Miyake", "https://github.com/kaymmm"] translators: - ["Christian Albrecht", "https://github.com/coastalchief"] - ["Dennis Keller", "https://github.com/denniskeller"] -filename: ruby-de.rb + - ["Paul Götze", "https://gitub.com/paulgoetze"] lang: de-de --- -# Dies ist ein Kommentar +```ruby +# Das ist ein Kommentar =begin -Dies sind multi-line -Kommentare. Niemand benutzt -die wirklich. +Das ist ein mehrzeiliger Kommentar. +Die Anfangszeile muss mit "=begin" beginnen +und die Endzeile muss mit "=end" beginnen. + +Alternativ kannst du jede Zeile in einem +mehrzeiligen Kommentar mit dem # Zeichen beginnen. =end -# Objekte - Alles ist ein Objekt +# In Ruby ist (fast) alles ein Objekt. +# Das schließt Zahlen ein... +3.class #=> Integer -## Zahlen sind Objekte -``` -3.class #=> Fixnum -3.to_s #=> "3" -``` +# ...und Zeichenketten (Strings)... +"Hallo".class #=> String -### Simple Arithmetik -``` +# ...und sogar Methoden! +"Hallo".method(:class).class #=> Method + +# Simple Arithmetik 1 + 1 #=> 2 8 - 1 #=> 7 10 * 2 #=> 20 35 / 5 #=> 7 -2**5 #=> 32 -``` +2 ** 5 #=> 32 +5 % 3 #=> 2 -// Arithmetik ist aber eigentlich nur syntaktischer Zucker -// um eine Methode eines Objekt aufzurufen -``` +# Bitweise Operatoren +3 & 5 #=> 1 +3 | 5 #=> 7 +3 ^ 5 #=> 6 + +# Arithmetik ist aber eigentlich nur syntaktischer Zucker +# um eine Methode eines Objekts aufzurufen 1.+(3) #=> 4 10.* 5 #=> 50 -``` +100.methods.include?(:/) #=> true -## Special values sind Objekte -``` -nil # Nothing to see here -true # truth -false # falsehood +## Spezielle Werte sind Objekte +nil # Equivalent zu null in anderen Sprachen +true # Wahrheitswert +false # Falschheitswert nil.class #=> NilClass true.class #=> TrueClass false.class #=> FalseClass -``` -## Objektvergleiche -### Gleicheit -``` +# Gleicheit 1 == 1 #=> true 2 == 1 #=> false -``` -### Ungleichheit -``` + +# Ungleichheit 1 != 1 #=> false 2 != 1 #=> true -``` -### Neben false selbst, nil ist ein anderer 'falsey' Wert -``` -!nil #=> true -!false #=> true -!0 #=> false -``` -### Weitere Vergleiche -``` + +# Neben false selbst, ist nil der einzige andere +# zu Falsch evaluierende Wert + +!!nil #=> false +!!false #=> false +!!0 #=> true +!!"" #=> true + +# Weitere Vergleiche 1 < 10 #=> true 1 > 10 #=> false 2 <= 2 #=> true 2 >= 2 #=> true -``` + +# Kombinierter Vergleichsoperator (gibt `1` zurück wenn das erste Argument +# größer ist, und `-1`, wenn das zweite Argument größer ist, sonst `0`) +1 <=> 10 #=> -1 (1 < 10) +10 <=> 1 #=> 1 (10 > 1) +1 <=> 1 #=> 0 (1 == 1) + ### Logische Operatoren -``` true && false #=> false true || false #=> true -!true #=> false -``` -Es gibt alternative Versionen der logischen Operatoren mit niedrigerer -Wertigkeit. Diese werden meistens bei Flow-Control eingesetzt, um -verschiedenen Ausdrücke zu verketten bis einer true oder false zurück -liefert. +# Es gibt alternative Versionen der logischen Operatoren mit niedrigerer +# Wertigkeit. Diese werden meistens zur Flusskontrolle eingesetzt, um +# verschiedenen Ausdrücke zu verketten bis einer true oder false zurück +# liefert. -#### and -##### `do_something_else` wird nur ausgewertet wenn `do_something` true ist. +# `do_something_else` wird nur ausgewertet wenn `do_something` true ist. do_something() and do_something_else() - -#### or -#####`log_error` wird nur ausgewertet wenn `do_something` false ist. +# `log_error` wird nur ausgewertet wenn `do_something` false ist. do_something() or log_error() -## Strings sind Objekte -``` -'I am a string'.class #=> String -"I am a string too".class #=> String +# String Interpolation +placeholder = 'Ruby' +"Ich kann in #{placeholder} Platzhalter mit doppelten Anführungszeichen füllen." +#=> "Ich kann in Ruby Platzhalter mit doppelten Anführungszeichen füllen." -platzhalter = 'Ruby' -"Ich kann in #{placeholder} Platzhalter mit doppelten Anführungsstrichen füllen." -``` -Einfache Anführungszeichen sollten bevorzugt werden. -Doppelte Anführungszeichen führen interne Berechnungen durch. +# Du kannst Strings mit `+` verbinden, nicht jedoch mit anderen Typen +'hallo ' + 'Welt' #=> "hallo Welt" +'Hallo ' + 3 #=> TypeError: no implicit conversion of Integer into String +'hallo ' + 3.to_s #=> "hallo 3" +"hallo #{3}" #=> "hallo 3" + +# ...oder Strings mit Operatoren kombinieren +'hallo ' * 3 #=> "hallo hallo hallo " + +# ...oder Strings an andere Strings anhängen +'hallo' << ' Welt' #=> "hallo Welt" + +# Du kannst Text mit einer neuen Zeile am Ende ausgeben +puts "Ich gebe Text aus!" +#=> Ich gebe Text aus! +#=> nil + +# ...oder Text ohne einen Zeilenumbruch ausgeben +print "Ich gebe Text aus!" +#=> "Ich gebe Text aus!" => nil -### Strings können verbunden werden, aber nicht mit Zahlen -``` -'hello ' + 'world' #=> "hello world" -'hello ' + 3 #=> TypeError: can't convert Fixnum into String -``` -#### Zahl muss in String konvertiert werden -``` -'hello ' + 3.to_s #=> "hello 3" -``` -### Text ausgeben -``` -puts "I'm printing!" -``` # Variablen -## Zuweisungen -### Diese Zuweisung gibt den zugeordneten Wert zurück -``` x = 25 #=> 25 x #=> 25 -``` -### Damit funktionieren auch mehrfache Zuweisungen -``` + +# Beachte, dass Zuweisungen den zugewiesenen Wert zurückgeben. +# D.h. du kannst mehrfache Zuweisungen machen. + x = y = 10 #=> 10 x #=> 10 y #=> 10 -``` -## Benennung -### Konvention ist snake_case -``` + +# Nutze snake_case für Variablennamen. snake_case = true -``` -### Benutze verständliche Variablennamen -``` -path_to_project_root = '/good/name/' -path = '/bad/name/' -``` -# Symbols (sind auch Objekte) -Symbols sind unveränderliche, wiederverwendbare Konstanten, welche intern -als integer repräsentiert werden. Sie werden häufig anstelle von Strings -verwendet, um sinnvoll Werte zu übermitteln. -Symbols werden mit dem Doppelpunkt gekennzeichnet. -``` +# Nutze verständliche Variablennamen. +path_to_project_root = '/guter/Name/' +m = '/schlechter/Name/' + + +# Symbole sind unveränderliche, wiederverwendbare Konstanten, welche intern +# als Integer repräsentiert werden. Sie werden häufig anstelle von Strings +# verwendet, um semantisch sinnvoll Werte zu übermitteln. +# Symbols werden mit dem Doppelpunkt gekennzeichnet. + :pending.class #=> Symbol + status = :pending + status == :pending #=> true + status == 'pending' #=> false + status == :approved #=> false -``` + +# Strings können in Symbole konvertiert werden und umgekehrt. +status.to_s #=> "pending" +"argon".to_sym #=> :argon + # Arrays -## Ein Array anlegen -``` +# Das ist ein Array. array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] -``` -## Array können verschiedene Typen beinhalten -``` +# Array können verschiedene Typen beinhalten [1, 'hello', false] #=> [1, "hello", false] -``` -## Wie bei arithmetischen Ausdrücken auch wird beim Zugriff auf -## [0] eigentlich die Methode [] des Array Objekts aufgerufen. -``` -array.[] 0 #=> 1 -array.[] 12 #=> nil -``` +## Arrays könnenindiziert werden. -## Arrays können von vorne indiziert werden -``` +# Von vorne... array[0] #=> 1 +array.first #=> 1 array[12] #=> nil -``` -## Arrays können von hinten indiziert werden -``` +# ...oder von hinten... array[-1] #=> 5 -``` +array.last #=> 5 -## Arrays können mit Start Index und Länge indiziert werden -``` +# ...oder mit einem Startindex und einer Länge... array[2, 3] #=> [3, 4, 5] -``` -## Arrays können mit einer Range indiziert werden -``` +# ...oder mit einem Range... array[1..3] #=> [2, 3, 4] -``` -## Einen Wert hinzufügen -``` +# Du kanns ein Array umkehren. +# Gib ein neues Array mit umgkehrten Werten zurück +[1,2,3].reverse #=> [3,2,1] + +# Kehre ein Array an Ort und Stelle um, um die Variable mit den +# umgekehrten Werten zu aktualisieren. +a = [1,2,3] +a.reverse! #=> a==[3,2,1] wegen des Aufrufs von reverse mit Ausrufezeichens ('!') + +# Wie bei der Arithmetik, ist Zugriff mit [index] nur +# syntaktischer Zucker für den Aufruf der `[]` Methode auf dem Objekt. +array.[] 0 #=> 1 +array.[] 12 #=> nil + +# Du kannst Werte zu einem Array hinzufügen... array << 6 #=> [1, 2, 3, 4, 5, 6] +# Oder so array.push(6) #=> [1, 2, 3, 4, 5, 6] -``` -## Testen, ob ein Element schon vorhanden ist -``` +# ...und testen ob ein Element schon vorhanden ist array.include?(1) #=> true -``` -# Hashes -Hashes sind das Hauptfeature um Key/Values zu speichern +# Hashes sind Rubys Hauptdatenstruktur for Schlüssel/Wert Paare. +# Hashes werden durch geschweifte Klammern gekennzeichnet. +hash = { 'Farbe' => 'grün', 'Nummer' => 5 } -## Ein Hash anlegen -``` -hash = { 'color' => 'green', 'number' => 5 } -hash.keys #=> ['color', 'number'] -``` +hash.keys #=> ['farbe', 'nummer'] -## Wert per key herausfinden -``` -hash['color'] #=> 'green' -hash['number'] #=> 5 -hash['nothing here'] #=> nil -// Fragen an einen Hash nach einem Schlüssel, der nicht existiert, ruft nil hervor: -``` +# Hashes can be quickly looked up by key. +hash['Farbe'] #=> "grün" +hash['Nummer'] #=> 5 -## Symbols können auch keys sein -``` -new_hash = { defcon: 3, action: true } -new_hash.keys #=> [:defcon, :action] -``` +# Abfragen eines nicht vorhandenen Schlüssels, gibt nil zurück. +hash['nicht vorhanden'] #=> nil -## Testen ob ein Key oder ein Value existiert -``` -new_hash.has_key?(:defcon) #=> true -new_hash.has_value?(3) #=> true -``` +# Wenn du Symbole als Schlüssel in einem Hash verwendest, kannst du +# eine alternative Syntax verwenden. +hash = { :defcon => 3, :action => true } +hash.keys #=> [:defcon, :action] -### Tipp: Arrays und Hashes sind Enumerable -### Und haben gemeinsame, hilfreiche Methoden wie: -### each, map, count, and more +hash = { defcon: 3, action: true } +hash.keys #=> [:defcon, :action] + +# Testen ob ein Schlüssel oder Wert im Hash existiert +hash.key?(:defcon) #=> true +hash.value?(3) #=> true + +# Tipp: Arrays und Hashes sind Enumerables! +# Sie haben viele nützliche Methoden gemein, wie each, map, count, und andere. # Kontrolstrukturen -## if -``` + +# Bedingungen if true - 'if statement' + 'wenn Bedingung' elsif false - 'else if, optional' + 'sonst wenn, optional' else - 'else, also optional' + 'sonst, auch optional' end -``` -## for - Allerdings werden for Schleifen nicht oft vewendet. -``` -for counter in 1..5 - puts "iteration #{counter}" -end -``` -## Stattdessen: "each" Methode und einen Bloch übergeben -Ein Block ist ein Codeteil, den man einer Methode übergeben kann -Ähnelt stark lambdas, anonymen Funktionen oder Closures in anderen -Programmiersprachen. -``` +# Wenn eine Kontrollstruktur keinen Code-Block, sondern einen einzigen +# Ausdruck ausführt, dann kannst du die nachgestellte if-Notation verwenden +warnings = ['Nachname fehlt', 'Adresse zu kurz'] +puts("Vorhandene Warnungen:\n" + warnings.join("\n")) if !warnings.empty? + +# Formuliere die Bedingung um, wenn sich `unless` besser liest als `if` +puts("Vorhandene Warnungen:\n" + warnings.join("\n")) unless warnings.empty? + +# Schleifen +# Traditionell ist das Benutzen von `for` Schleifen in Ruby eher unüblich. +# Stattdessen werden diese mit Hilfe von Enumerables implementiert, was mit +# dem Aufrufen von `each` einhergeht. (1..5).each do |counter| - puts "iteration #{counter}" + puts "Iteration #{counter}" +end + +# Was in etwa das selbe ist wie Folgendes (selten in Ruby zu sehen). +for counter in 1..5 + puts "Iteration #{counter}" end -``` -Die each Methode einer Range führt den Block für jedes Element der Range aus. +# Das `do |variable| ... end` Konstrukt wird `block` genannt. +# Blocks sind vergleichbar mit Lambdas, anonymen Funktionen +# oder Closures in anderen Programmiersprachen. +# Sie können als Objekte übergeben, aufgerufen oder als Methoden +# zugewiesen werden. -Dem Block wird ein "counter" parameter übergeben. +# Die `each` Methode eines Ranges führt den Block einmal für jedes +# Element des Ranges aus. +# Dem Block wird eine counter Variable als Parameter übergeben. -### Den Block kann man auch in geschweiften Klammern schreiben -``` -(1..5).each { |counter| puts "iteration #{counter}" } -``` +# Du kannst einen Block auch mit geschweiften Klammern schreiben. +(1..5).each { |counter| puts "Iteration #{counter}" } -### Each kann auch über den Inhalt von Datenstrukturen iterieren -``` +# Each kann auch über den Inhalt von Datenstrukturen iterieren. array.each do |element| - puts "#{element} is part of the array" + puts "#{element} is Teil des Arrays" end + hash.each do |key, value| - puts "#{key} is #{value}" + puts "#{key} ist #{value}" +end + +# Um auf den Laufindex zuzugreifen kannst du `each_with_index` verwenden +# und eine index Variable definieren. +array.each_with_index do |element, index| + puts "#{element} ist Nummer #{index} im Array" end counter = 1 while counter <= 5 do - puts "iteration #{counter}" + puts "Iteration #{counter}" counter += 1 end -``` +#=> Iteration 1 +#=> Iteration 2 +#=> Iteration 3 +#=> Iteration 4 +#=> Iteration 5 + +# Es gibt einige andere hilfreiche Schleifenfunktionen in Ruby. +# Wie etwa 'map', 'reduce', 'inject' und viele andere mehr. +# Map zum Beispiel iteriert über das Array, führt für jedes Element +# die Anweisungen aus, +# die im Block definiert sind und gibt ein völlig neues Array zurück. +array = [1,2,3,4,5] +doubled = array.map do |element| + element * 2 +end +puts doubled +#=> [2,4,6,8,10] +puts array +#=> [1,2,3,4,5] -## case -``` +# Case Konstruct grade = 'B' case grade when 'A' - puts 'Way to go kiddo' + puts 'So wird’s gemacht' when 'B' - puts 'Better luck next time' + puts 'Viel Glück beim nächsten Mal' when 'C' - puts 'You can do better' + puts 'Das kannst du besser' when 'D' - puts 'Scraping through' + puts 'Gerade so durch' when 'F' - puts 'You failed!' + puts 'Durchgefallen!' else - puts 'Alternative grading system, eh?' + puts 'Anderes Bewertungssystem, was?' end -=> "Better luck next time" -``` +#=> "Viel Glück beim nächsten Mal" -### Case können auch ranges -``` +# Case kann auch Ranges benutzen grade = 82 case grade when 90..100 - puts 'Hooray!' + puts 'Hurra!' when 80...90 - puts 'OK job' + puts 'OK gemacht' else - puts 'You failed!' + puts 'Durchgefallen!' end -=> "OK job" -``` +#=> "OK gemacht" -# Exception handling: -``` +# Fehlerbehandlung begin - # code here that might raise an exception - raise NoMemoryError, 'You ran out of memory.' + # Code der einen Fehler wirft... + raise NoMemoryError, 'Dein Speicher ist voll.' rescue NoMemoryError => exception_variable - puts 'NoMemoryError was raised', exception_variable + puts 'NoMemoryError ist aufgetreten', exception_variable rescue RuntimeError => other_exception_variable - puts 'RuntimeError was raised now' + puts 'RuntimeError ist aufgetreten' else - puts 'This runs if no exceptions were thrown at all' + puts 'Das wird ausgeführt, wenn keine Fehler geworfen wurden' ensure - puts 'This code always runs no matter what' + puts 'Dieser Code wird immer ausgeführt, egal was vorher passiert' end -``` -# Funktionen -``` + +# Methoden + def double(x) x * 2 end -``` -## Funktionen (und Blocks) -## geben implizit den Wert des letzten Statements zurück -``` + +# Methoden (und Blocks) geben implizit den Wert des letzten Anweisung zurück. double(2) #=> 4 -``` -### Klammern sind optional wenn das Ergebnis nicht mehrdeutig ist -``` +# Klammern sind optional wenn die Anweisung dadurch nicht mehrdeutig wird. double 3 #=> 6 + double double 3 #=> 12 + def sum(x, y) x + y end -``` -### Methoden Parameter werden per Komma getrennt -``` +# Die Argumente einer Methode werden durch ein Komma getrennt. sum 3, 4 #=> 7 + sum sum(3, 4), 5 #=> 12 -``` -## yield -### Alle Methoden haben einen impliziten, optionalen block Parameter -### Dieser wird mit dem Schlüsselword "yield" aufgerufen -``` +# yield +# Alle Methoden haben implizit einen optionalen block Parameter. +# Dieser kann durch das Schlüsselwort 'yield' ausgeführt werden. def surround puts '{' yield puts '}' end -surround { puts 'hello world' } -``` -## Einen Block kann man auch einer Methoden übergeben -### "&" kennzeichnet die Referenz zum übergebenen Block -``` +surround { puts 'hallo Welt' } + +#=> { +#=> hallo Welt +#=> } + +# Blocks können in ein 'Proc' Objekt umgewandelt werden. +# Dieses ist eine Art Container um den Block und erlaubt ihn an eine +# andere Methode zu übergeben, ihn in einen anderen Gültigkeitsbereicht +# einzubinden oder ihn andersweitig zu verändern. +# Am häufigsten findet man dies bei Parameterlisten von Methoden, in Form +# eines letzten '&block' Parameters, der den Block – wenn es einen gibt – +# entgegen nimmt und ihn in ein 'Proc' umwandelt. Die Benennung '&block' ist +# hier nur eine Konvention; es würde genauso mit '&pineapple' funktionieren. def guests(&block) - block.call 'some_argument' + block.class #=> Proc + block.call(4) end -``` -### Eine Liste von Parametern kann man auch übergeben, -### Diese wird in ein Array konvertiert -### "*" kennzeichnet dies. -``` +# Die 'call' Methode eines Proc ist ganz ähnlich zum Aufruf von 'yield', wenn +# ein Block vorhanden ist. Die Argumente, die 'call' übergeben werden, werden +# als Argumente and den Block weitergereicht. + +guests { |n| "Du hast #{n} Gäste." } +# => "Du hast 4 Gäste." + +# Du kannst eine Liste von Argumenten übergeben, die dann in ein Array +# umgewandelt werden. Dafür gibt es den splat-Operator (`*`). def guests(*array) array.each { |guest| puts guest } end -``` + +# Destrukturierung + +# Ruby destrukturiert Arrays automatisch beim Zuweisen mehrerer Variablen. +a, b, c = [1, 2, 3] +a #=> 1 +b #=> 2 +c #=> 3 + +# In manchen Fällen will man den splat-Operator (`*`) verwenden um ein Array in +# eine Liste zu destrukturieren. +ranked_competitors = ["John", "Sally", "Dingus", "Moe", "Marcy"] + +def best(first, second, third) + puts "Gewinner sind #{first}, #{second} und #{third}." +end + +best *ranked_competitors.first(3) #=> Gewinner sind John, Sally and Dingus. + +# Der splat-Operator kann auch in Parametern verwendet werden. +def best(first, second, third, *others) + puts "Gewinner sind #{first}, #{second} und #{third}." + puts "Es gab #{others.count} andere Teilnehmer." +end + +best *ranked_competitors +#=> Gewinner sind John, Sally und Dingus. +#=> Es gab 2 andere Teilnehmer. + +# Per Konvention enden alle Methoden, die einen Wahrheitswert zurück geben, mit einem +# Fragezeichen. +5.even? #=> false +5.odd? #=> true + +# Wenn ein Methodenname mit einem Ausrufezeichen endet, dann tut diese Methode +# per Konvention etwas Destruktives, wie z.B. das aufrufende Objekt zu +# verändern. +# Viele Mehtoden haben eine !-Version um eine direkte Änderung zu machen und +# eine Nicht-!-Version, die ein neues Objekt mit den Veränderungen zurück gibt. +company_name = "Dunder Mifflin" +company_name.upcase #=> "DUNDER MIFFLIN" +company_name #=> "Dunder Mifflin" +# Diesmal verändern wir company_name direkt. +company_name.upcase! #=> "DUNDER MIFFLIN" +company_name #=> "DUNDER MIFFLIN" + # Klassen -## Werden mit dem class Schlüsselwort definiert -``` + +# Du kannst eine Klasse mit dem Schlüsselwort 'class' definieren. class Human -``` -### Konstruktor bzw. Initializer -``` + # Eine Klassenvariable. Sie wird von allen Instanzen einer Klasse geteilt. + @@species = 'H. sapiens' + + # Konstruktor bzw. Initializer def initialize(name, age = 0) - # Assign the argument to the "name" instance variable for the instance + # Weise das Argument der Instanzvariable 'name' zu. @name = name - # If no age given, we will fall back to the default in the arguments list. + # Wenn kein 'age' angegeben wurde wird der Standartwert aus der Argumentenlist verwendet. @age = age end -``` -### setter Methode -``` + # Setter Methode def name=(name) @name = name end -``` -### getter Methode -``` + + # Getter Methode def name @name end -``` -#### getter können mit der attr_accessor Methode vereinfacht definiert werden -``` + # Getter & Setter können auch kürzer mit der attr_accessor Methode erstellt werden. attr_accessor :name - # Getter/setter methods can also be created individually like this + + # Getter & Setter Methoden können auch einzeln erstellt werden. attr_reader :name attr_writer :name - # A class method uses self to distinguish from instance methods. - # It can only be called on the class, not an instance. + + # Eine Klassenmethode unterscheidet sich durch ein 'self' von einer + # Instanzmethode. + # Sie kann nur auf der Klasse und nicht auf einer Instanz der Klasse + # aufgerufen werden. def self.say(msg) puts msg end + def species @@species end end -``` -## Eine Klasse instanziieren -``` +# Instanziieren einer Klasse jim = Human.new('Jim Halpert') dwight = Human.new('Dwight K. Schrute') -``` -## Methodenaufrufe -``` +# Du kannst die Methoden des erstellten Objekts aufrufen. jim.species #=> "H. sapiens" jim.name #=> "Jim Halpert" jim.name = "Jim Halpert II" #=> "Jim Halpert II" jim.name #=> "Jim Halpert II" dwight.species #=> "H. sapiens" dwight.name #=> "Dwight K. Schrute" -``` -## Eine Klassenmethode aufrufen -``` +# Aufrufen einer Klassenmethode Human.say('Hi') #=> "Hi" -``` -## Variable Gültigkeit -### Variablen die mit "$" starten, gelten global -``` -$var = "I'm a global var" +# Der Gültigkeitsbereich einer Variablen wird durch ihren Namen definiert. +# Variablen, die mit $ beginnen sind global gültig. +$var = "Ich bin eine globale Variable" defined? $var #=> "global-variable" -``` -### Variablen die mit "@" starten, gelten für die Instanz -``` -@var = "I'm an instance var" +# Variablen, die mit @ beginnen, sind innerhalb einer Instanz gültig. +@var = "Ich bin eine Instanzvariable" defined? @var #=> "instance-variable" -``` -### Variablen die mit "@@" starten, gelten für die Klasse -``` -@@var = "I'm a class var" +# Variablen, die mit @@ beginnen, sind für die Klasse gültig. +@@var = "Ich bin eine Klassenvariable" defined? @@var #=> "class variable" -``` -### Variablen die mit einem Großbuchstaben anfangen, sind Konstanten -``` -Var = "I'm a constant" +# Variablen, die mit einem Großbuchstaben beginnen, sind Konstanten +Var = "Ich bin eine Konstante" defined? Var #=> "constant" -``` -## Class ist auch ein Objekt -### Hat also auch Instanzvariablen -### Eine Klassenvariable wird innerhalb der Klasse und Ableitungen geteilt. +# Class ist in Ruby auch ein Objekt. Deshalb kann eine Klasse Instanzvariablen +# haben. Eine Klassenvariable wird zwischen der Klasse und all ihren +# Ableitungen geteilt. -### Basis Klasse -``` +# Basis Klasse class Human @@foo = 0 + def self.foo @@foo end + def self.foo=(value) @@foo = value end end -``` -### Abgeleitete Klasse -``` +# Abgeleitete Klasse class Worker < Human end -Human.foo # 0 -Worker.foo # 0 -Human.foo = 2 # 2 -Worker.foo # 2 -``` -### Eine Klasseninstanzvariable wird nicht geteilt -``` +Human.foo #=> 0 +Worker.foo #=> 0 + +Human.foo = 2 +Worker.foo #=> 2 + +# Ableitungen einer Klasse haben keinen Zugriff auf eine Eine Klassen-Instanzvariable. class Human @bar = 0 + def self.bar @bar end + def self.bar=(value) @bar = value end end -``` -``` + class Doctor < Human end -``` -``` -Human.bar # 0 -Doctor.bar # nil -``` -``` + +Human.bar #=> 0 +Doctor.bar #=> nil + module ModuleExample def foo 'foo' end end -``` -### Module einbinden, heisst ihre Methoden an die Instanzen der Klasse zu binden -### Module erweitern, heisst ihre Mothden an die Klasse selbst zu binden -``` + +# Ein Einbinden (include) eines Moduls bindet seine Methoden an die Instanzen +# der Klasse. +# Ein Erweitern (extend) eines Moduls bindet seine Methoden an die Klasse +# selbst. class Person include ModuleExample end -``` -``` + class Book extend ModuleExample end -``` -``` -Person.foo # => NoMethodError: undefined method `foo' for Person:Class -Person.new.foo # => 'foo' -Book.foo # => 'foo' -Book.new.foo # => NoMethodError: undefined method `foo' -``` -### Callbacks werden ausgeführt, wenn ein Modul eingebunden oder erweitert wird -``` - module ConcernExample - def self.included(base) - base.extend(ClassMethods) - base.send(:include, InstanceMethods) - end - module ClassMethods - def bar - 'bar' - end - end - module InstanceMethods - def qux - 'qux' - end + +Person.foo #=> NoMethodError: undefined method `foo' for Person:Class +Person.new.foo #=> "foo" +Book.foo #=> "foo" +Book.new.foo #=> NoMethodError: undefined method `foo' + + +# Callbacks werden ausgeführt, wenn ein Modul eingebunden oder erweitert wird. +module ConcernExample + def self.included(base) + base.extend(ClassMethods) + base.send(:include, InstanceMethods) + end + + module ClassMethods + def bar + 'bar' end end - class Something - include ConcernExample + + module InstanceMethods + def qux + 'qux' + end end -``` -``` -Something.bar # => 'bar' -Something.qux # => NoMethodError: undefined method `qux' -Something.new.bar # => NoMethodError: undefined method `bar' -Something.new.qux # => 'qux' +end + +class Something + include ConcernExample +end + +Something.bar #=> "bar" +Something.qux #=> NoMethodError: undefined method `qux' +Something.new.bar #=> NoMethodError: undefined method `bar' +Something.new.qux #=> "qux" ``` -## Weiterführende Hinweise +## Weitere Links -//EN +_(z.T. auf Englisch)_ -- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges. -- [Official Documentation](http://www.ruby-doc.org/core-2.1.1/) +- [Offizielle Ruby Website](https://www.ruby-lang.org/de/) +- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - Eine Variante dieses Dokuments mit in-Browser Challenges. +- [RubyMonk](https://rubymonk.com/) - Lerne Ruby mit einer Reihe interaktiver Tutorials. +- [Offizielle Dokumentation](http://ruby-doc.org/core) - [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/) -- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online. -- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide. +- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - Eine ältere [freie Ausgabe](http://ruby-doc.com/docs/ProgrammingRuby/) ist online verfügbar. +- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - Ein von der Community erstellter Ruby coding style guide. +- [Try Ruby](http://tryruby.org) - Lerne die Grundlagen der Ruby Programmiersprache, interaktiv im Browser. |