Die Sprache Ruby

Layout der Quellen

a = 1

b = 2; c = 3

d = 4 + 5 +      # braucht kein '\'
    6 + 7

e = 8 + 9   \
    + 10         # '\' benötigt

echo 'print "Hello\n"' | ruby

BEGIN und END Blöcke

BEGIN {
  begin code
}

END {
  end code
}

Allgemein begrenzter Input

Allgemein begrenzter Input Typ Bedeutung Siehe Seite %q String mit einfachen Anführungszeichen 204 %Q, % String mit doppelten Anführungszeichen 204 %w Array aus Tokens 206 %r Muster eines regulären Ausdrucks 207 %x Shell-Kommando 220

%q/this is a string/
%q-string-
%q(a (nested) string)

%q{def fred(a)
     a.each { |i| puts i }
   end}

Die Basis-Typen

Integer und Fließkomma-Zahlen

123456                    # Fixnum
123_456                   # Fixnum (Underscore wird ignoriert)
-543                      # Negative Fixnum
123_456_789_123_345_789   # Bignum
0xaabb                    # Hexadezimal
0377                      # Oktal
-0b1010                   # Binär (negativ)
0b001_001                 # Binär
?a                        # Zeichen-Code
?A                        # Zeichen-Code des Großbuchstabens
?\C-a                     # Control-a = A - 0x40
?\C-A                     # Großschreibung bei Control wird ignoriert
?\M-a                     # Meta setzt Bit 7
?\M-\C-a                  # Meta- und Control-a

Strings

Ersetzungen bei Strings in doppelten Anführungszeichen \a Bell/alert (0x07) \nnn Oktal nnn \b Backspace (0x08) \xnn Hex nn \e Escape (0x1b) \cx Control-x \f Formfeed (0x0c) \C-x Control-x \n Newline (0x0a) \M-x Meta-x \r Return (0x0d) \M-\C-x Meta-control-x \s Space (0x20) \x x \t Tab (0x09) #{expr} Wert von expr \v Vertical tab (0x0b)

a = 123
print <<HIER
Regeln für doppelte \
Anführungszeichen gelten.
Sum = #{a + 1}
HIER

print <<-'DORT'
    Einfache Anführungszeichen.
    Oben stand auch #{a + 1}
    DORT

Regeln für doppelte Anführungszeichen gelten.
Sum = 124
    Einfache Anführungszeichen
    Oben stand auch #{a + 1}

for i in 1..3
  print 'hello'.id, " "
end

537685230 537685200 537685170

Ranges

Arrays

arr = [ fred, 10, 3.14, "This is a string", barney("pebbles"), ]

Hashes

colors = { "red"   => 0xf00,
           "green" => 0x0f0,
           "blue"  => 0x00f
         }

Bedingungen für den Hash-Schlüssel

Symbole

:Object
:myVariable

Reguläre Ausdrücke

/pattern/
/pattern/options
%r{pattern}
%r{pattern}options
Regexp.new( 'pattern' [, options] )

Optionen für Reguläre Ausdrücke

Muster für reguläre Ausdrücke

reguläre Zeichen

Alle Zeichen außer ., |, (, ), [, \, ^, {, +, $, * und ? passen auf sich selber. Um eines von diesen Zeichen zu erfassen stellt man einen Backslash voran.

^

Erfasst den Zeilenanfang.

$

Erfasst das Zeilenende.

\A

Erfasst den Anfang des Strings.

\z

Erfasst das Ende des Strings.

\Z

Erfasst das Ende des Strings außer der String hört mit einem ``\n'' (Newline) auf, dann erfasst es die Stelle direkt davor.

\b, \B

Erfasst eine Wortgrenze bzw. eben gerade nicht.

[characters]

Passt auf jedes einzelne Zeichen zwischen den Klammern. Die Zeichen |, (, ), [, ^, $, * und ?, die sonst eine spezielle Bedeutung haben, verlieren diese hier. Die Zeichenfolgen \nnn, \xnn, \cx, \C-x, \M-x und \M-\C-x besitzen die Bedeutung wie in Tabelle 18.2 auf Seite 205 angegeben. Die Folgen \d, \D, \s, \S, \w und \W sind Abkürzungen für Gruppen von Zeichen, wie in Tabelle 5.1 auf Seite 62 anbegeben. Die Folge c₁-c₂ repräsentiert alle Zeichen zwischen c₁ und c₂, Grenzen inklusive. Die literalen Zeichen ] oder - müssen direkt nach der öffnenden Klammer kommen. Ein Aufwärtspfeil (^), der direkt nach der öffnenden Klammer kommt, negiert den Sinn des Musters, das Muster erfasst dann alle Zeichen, die nicht in der Zeichenklasse sind.

\d, \s, \w

Dies sind Abkürzungen für Zeichenklassen, die Ziffern, Whitespaces bzw. Wort-Zeichen erfassen. \D, \S und \W erfassen Zeichen, die keine Ziffern, Whitespaces bzw. Wortzeichen sind. Diese Abkürzungen werden in Tabelle 5.1 auf Seite 62 zusammengefasst.

. (Punkt)

Falls außerhalb von eckigen Klammern: erfasst jedes Zeichen außer Newline. (Mit der /m-Option auch Newline).

re*

Erfasst null oder mehr Auftreten von re.

re+

Erfasst ein oder mehr Auftreten von re.

re{m,n}

Erfasst mindestens ``m'' und höchstens ``n'' Auftreten von re.

re?

Erfasst null oder ein Auftreten von re. Die *, + und {m,n} Modifikatoren sind defaultmäßig gierig. Gefolgt von einem Fragezeichen sind sie es nicht mehr.

re1|re2

Erfasst entweder re1 oder re2. | besitzt geringe Priorität.

(...)

Klammern benutzt man zum Zusammenfassen von regulären Ausdrücken. Als Beispiel: Das Muster /abc+/ erfasst einen String mit einem ``a,'' einem ``b'' und einem oder mehreren ``c''s. /(abc)+/ erfasst eine oder mehr Folgen von ``abc''. Klammern benutzt man auch, um die Ergebenisse des Mustervergleichs einzusammeln. Für jede öffnende Klammer speichert Ruby das Ergebnis dieses Teiltreffers bis zur schließenden Klammer als aufzählende Gruppen. Innerhalb des gleichen Musters zeigt \1 auf den Treffer der ersten Gruppe, \2 auf den der zweiten Gruppe und so weiter. Außerhalb des Musters dienen die speziellen Variablen $1, $2und so weiter dem gleichen Zweck.

Ersetzungen

#{...}

Ersetzt einen Ausdruck, wie bei Strings. Defaultmäßig wird die Ersetzung bei jeder Auswertung des Literals des regulären Ausdrucks durchgeführt. Mit der /o-Option nur beim ersten Mal.

\0, \1, \2, ... \9, \&, \`, \', \+

Ersetzt den Wert, der vom nten gruppierten Unterausdruck erfasst wurde, bzw. vom gesamten Ausdruck, vorausgehendem oder nachfolgendem Text oder der höchsten Gruppe.

Erweiterungen

(?# >Kommentar)

Setzt einen Kommentar in das Muster. Der Inhalt wird beim Muster-Vergleich ignoriert.

(?:re)

Fasst re in einer Gruppe zusammen, ohne Rückwärtsreferenzen zu erzeugen. Das ist oft nützlich, wenn man einen Satz von Anweisungen gruppieren muss, aber den Wert von $1 und so nicht ändern will. In dem folgenden Beispiel erfassen beide Muster ein Datum mit entweder Doppelpunkten oder Leerzeichen zwischen Monat, Tag und Jahr. Die erste Form speichert die Trennzeichen in $2 und $4, die zweite nicht.

date = "12/25/01"
date =~ %r{(\d+)(/|:)(\d+)(/|:)(\d+)}
[$1,$2,$3,$4,$5]	»	["12", "/", "25", "/", "01"]
date =~ %r{(\d+)(?:/|:)(\d+)(?:/|:)(\d+)}
[$1,$2,$3]	»	["12", "25", "01"]

(?=re)

Erfasst re an dieser Stelle, aber benutzt es danach nicht (auch bekannt als ``null-breite positive Vorausschau'')(Na ja, das ist nicht so gut übersetzt, aber es ist übersetzt, der Übersetzter). Damit kann man den Kontext eines Musters mit erfassen, ohne $& zu beeinflussen. Im nächstan Beispiel erfasst die scan-Methode Wörter mit nachfolgendem Komma, ohne dass die Kommas im Ergebnis enthalten sind.

str = "red, white, and blue"
str.scan(/[a-z]+(?=,)/)	»	["red", "white"]

(?!re)

Erfasst das, was re nicht erfasst. Benutzt das Gefundene nicht (null-breite negative Vorausschau). Zum Beispiel erfasst /hot(?!dog)(\w+)/ jedes Wort, das die Buchstaben ``hot'' enthält, an denen kein ``dog'' hängt. Zurück geliefert wird das Ende des Wortes in $1.

(?>re)

Verschachtelt einen unabhängigen regulären Ausdruck in einem anderen regulären Ausdruck. Dieser Ausdruck sitzt dann anstelle der gefundenen Position. Wenn er Zeichen beansprucht, so stehen diese dem übergeordneten Ausdruck nicht mehr zur Verfügung. Dieses Konstrukt verhindert deshalb rekursive Suchen, was einen Performance-Vorteil mit sich bringen kann. Zum Beispiel benötigt das Muster /a.*b.*a/ exponetiell viel Zeit, wenn es auf einen String angewandt wird, der ein ``a'' enthält, gefolgt von mehreren ``b''s, aber ohne abschließendem ``a''. Dies kann vermieden werden, wenn man einen verschachtelten regulären Ausdruck benutzt /a(?>.*b).*a/. Bei dieser Form verbraucht der innere Ausdruck den ganzen Input-String bis hin zum letzten ``b''. Wenn dann auf das abschließende ``a'' geprüft wird, besteht keine Notwendigkeit mehr für eine Rekursion, und der Vergleich ist sofort beendet.

require "benchmark" include Benchmark str = "a" + ("b" * 5000) bm(8) do |test|   test.report("Normal:") { str =~ /a.*b.*a/ }   test.report("Nested:") { str =~ /a(?>.*b).*a/ } end

erzeugt:

user     system      total        real Normal:   2.620000   0.000000   2.620000 (  2.651591) Nested:   0.000000   0.000000   0.000000 (  0.000883)

(?imx)

Schaltet die dazugehörige ``i,''- ``m,''- oder ``x''-Option an. Der Effekt ist auf die Gruppe beschränkt, falls es innerhalb einer Gruppe benutzt wird.

(?-imx)

Schaltet die dazugehörige ``i,''- ``m,''- oder ``x''-Option ab.

(?imx:re)

Schaltet die dazugehörige ``i,''- ``m,''- oder ``x''-Option für re an.

(?-imx:re)

Schaltet die dazugehörige ``i,''- ``m,''- oder ``x''-Option für re ab.

Namen

Reservierte Wörter __FILE__ and def end in or self unless __LINE__ begin defined? ensure module redo super until BEGIN break do false next rescue then when END case else for nil retry true while alias class elsif if not return undef yield

fred  anObject  _x  three_two_one

@name  @_  @Size

@@name  @@_  @@Size

module Math
  PI = 3.1415926
end
class BigBlob

$params  $PROGRAM  $!  $_  $-a  $-.

Variablen/Methoden-Mehrdeutigkeit

def a
  print "Function 'a' called\n"
  99
end

for i in 1..2
  if i == 2
    print "a=", a, "\n"
  else
    a = 1
    print "a=", a, "\n"
  end
end

a=1
Function 'a' called
a=99

a = 1 if false; a

Variablen und Konstanten

MY_CONST = 1
MY_CONST = 2   # generates a warning

prog.rb:2: warning: already initialized constant MY_CONST

Gültigkeitsbereich von Konstanten und Variablen

class Song
  @@count = 0
  def initialize
    @@count += 1
  end
  def Song.getCount
    @@count
  end
end

class Holder
  @@var = 99
  def Holder.var=(val)
    @@var = val
  end
end

a = Holder.new
def a.var
  @@var
end

a = [ 1, 2, 3 ]
a.each { |i|  puts i  }  # i local to block
a.each { |$i| puts $i }  # assigns to global $i
a.each { [email protected]| puts @i }  # assigns to instance variable @i
a.each { |I|  puts I  }  # generates warning assigning to constant
a.each { |b.meth| }      # invokes meth= in object b
sum = 0
var = nil
a.each { |var| sum += var }  # uses sum and var from enclosing scope

Vordefinierte Variablen

Informationen über Exceptions

Variablen zur Muster-Erfassung

Input/Output-Variablen

Variablen der Ausführungs-Umgebung

Standard Objekte

Globale Konstanten

Ausdrücke

Einfache Terme

• Literal. Ruby-Literale sind Zahlen, Strings, Arrays, Hashes, Bereiche, Symbole und reguläre Ausdrücke. Sie sind ab Seite 203 beschrieben.

• Shell-Kommando. Ein Shell-Kommando ist ein in Backquotes gesetzer String oder ein allgemein begrenzter String mit %x am Anfang. Der Wert dieses Strings ist der Standard-Output des Kommandos, ausgeführt auf der Standard-Shell des Betriebssystems. Die Ausführung besetzt auch die $?-Variable mit dem Rückgabewert des Kommandos.

  filter = "*.c" files = `ls #{filter}` files = %x{ls #{filter}}

• Symbol-Generator. Ein Symbol-Objekt wird erzeugt durch das Voranstellen eines Doppelpunkts vor einen Operator, Variable, Konstante, Methode, Klasse oder Modul. Das Symbol-Objekt ist einmalig für jeden unterschiedlichen Namen, aber referenziert nicht auf die spezielle Instanz des Namens, so ist etwa das Symbol für:fred immer das gleiche, egal in welchem Kontext. Ein Symbol ist wie ein Atom in anderen hoch-leveligen Sprachen.

• Variablen-Referenz oder Konstanten-Referenz. Eine Variable wird referenziert durch Angabe ihres Namens. Abhängig vom Gültigkeitsbereich (siehe Seite 214) wird eine Konstante entweder durch Angabe ihres Namens oder durch dessen genaue Bestimmung mit ihrer Klasse oder ihrem Modul um dem Bereichs-Operator (``::'').

  barney    # Variablen-Referenz APP_NAMR  # Konstanten-Referenz Math::PI  # genau bestimmte Konstanten-Referenz

• Methoden-Aufruf. Die verschiedenen Arten, eine Methode aufzurufen, werden ab Seite 229 beschrieben.

Operator-Ausdrücke

Ruby-Operatoren (nach Priorität geordnet) Methode Operator Beschreibung Y [ ] 0[ ]= Referenz auf ein Element, Satz von Elementen Y ** Exponentiation Y ! 0~ 0+ 0-- Not, Komplement, unäres Plus und Minus (die Methoden-Namen für die letzen beiden sind +@ und -@) Y * 0/ 0% Multiplizieren, Dividieren und Modulo Y + 0-- Plus und Minus Y >> 0<< Rechter und linker Shift Y & Bitweises `and' Y ^ 0| Bitweises exklusives `or' und normales `or' Y <= 0< 0> 0>= Vergleichs-Operator Y <=> 0== 0=== 0!= 0=~ 0!~ Gleichheits- und Muster-Vergleichs-Operator (!= und !~ dürfen nicht als Methoden definiert werden) && logisches `and' || Logisches `or' .. 0... Bereich(inklusive und exklusive rechter Rand) ? : Ternäres if-then-else = 0%= 0{ /= 0--= 0+= 0|=&= 0>>= 0<<= 0*= 0&&= 0||= 0**= Zuweisung defined? Test ob Symbol definiert ist not Logische Negation or 0and Logischer Vergleich if 0unless 0while 0until Ausdrucks-Modifikator begin/end Block-Ausdruck

Mehr über Zuweisungen

a, b, c = 1, "cat", [ 3, 4, 5 ]

anObj = A.new
anObj.value = "hello"   # äquivalent zu anObj.value=("hello")

Zuordnung von Element-Referenz zu Methoden-Aufruf Element-Referenz wirklicher Methoden-Aufruf anObj[] = "one" anObj.[]=("one") anObj[1] = "two" anObj.[]=(1, "two") anObj["a", /^cat/] = "three" anObj.[]=("a", /^cat/, "three")

Parallele Zuweisung

1. Wenn dem letzten rvalue ein Sternchen vorangestellt ist und es ist ein Objekt der Klasse Array, dann wird der rvalue ersetzt durch die Elemente des Arrays, wobei jedes Element wieder einen eigenen rvalue ergibt.
2. Wenn die Zuweisung mehrere lvalues und einen rvalue enthält, dann wird der rvalue in ein Array konvertiert, dieses wird in einen Satz von rvalues expandiert wie unter (1) beschrieben.
3. Aufeinander folgende rvalues werden den lvalues zugewiesen. Diese Zuweisung geschieht tatsächlich parallel, so dass (zum Beispiel) a,b=b,a die Werte in ``a'' und ``b'' austauscht.
4. Wenn mehr lvalues als rvalues vorhanden sind, bekommen die überzähligen nil zugewiesen.
5. Wenn mehr rvalues als lvalues vorhanden sind, werden die überzähligen ignoriert.
6. Diese Regeln werden leicht abgewandelt, wenn dem letzten lvalue ein Sternchen vorangestellt ist. Dieser lvalue erhält dann immer ein Array während der Zuweisung. Das Array besteht aus dem rvalue, der normalerweise diesem lvalue zugewiesen worden wäre, gefolgt von den restlichen rvalues (falls es noch welche gibt).
7. Wenn der lvalue eine geklammerte Aufzählung ist, wird er wie eine verschachtelte Zuweisung behandelt und diese Aufzählung bekommt den dazugehörigen rvalue zugeweisen, wie in diesen Regeln beschrieben.

Block-Ausdrücke

begin
  body
end

Boolsche Ausdrücke

Wahrheits-Werte

And, Or, Not und Defined?

expr1  and  expr2expr1  &&   expr2

expr1  or  expr2expr1  ||  expr2

Vergleichs-Operatoren

Bereiche in Boolschen Ausdrücken

if  expr1 .. expr2
while  expr1 ... expr2

Reguläre Ausdrücke in boolschen Ausdrücken

if /re/ ...

if $_ =~ /re/ ...

If und Unless Ausdrücke

if boolean-expression[then]body
elsif boolean-expression[then]body
else
  body
end

unless boolean-expression[then]body
else
  body
end

If und Unless Modifikatoren

expression if     boolean-expression
expression unless boolean-expression

Ternärer Operator

boolean-expression ? expr1 : expr2

Case-Ausdruck

case target
  when [comparison]+[then]body
  when [comparison]+[then]body
  ...
[ else
    body]
 end

Schleifen

while boolean-expression[do]body
end

until boolean-expression[do]body
end

for [name]+ in expression[do]body
end

expression.each do | [name]+ |
  body
end

While- und Until-Modifikatioren

expression while boolean-expression
expression until boolean-expression

Break, Redo, Next und Retry

Methoden-Definition

  def defname[( [arg[=val]]*[, *vararg][, &blockarg] )]body
  end

defname
 <-
methodname




expr.methodname

class MyClass
  def MyClass.method      # Definition
  end
end

MyClass.method            # Aufruf

anObject = Object.new
def anObject.method       # Definition
end
anObject.method           # Aufruf

def (1.class).fred        # Empfänger darf ein Ausdruck sein
end
Fixnum.fred               # Aufruf

Methoden-Argumente

Aufruf einer Methode

[receiver. ]name[parameters][block]
[receiver::]name[parameters][block]


parameters
 <-
 ( [param]*[, hashlist][*array][&aProc] ) 


block
 <-
 { blockbody }     




 do blockbody end
  

def regular(a, b, *c)
  # ..
end
regular 1, 2, 3, 4
regular(1, 2, 3, 4)
regular(1, *[2, 3, 4])

aProc   = proc { 99 }
anArray = [ 98, 97, 96 ]

def block
  yield
end
block { }
block do
      end
block(&aProc)

def all(a, b, c, *d, &e)
  puts "a = #{a}"
  puts "b = #{b}"
  puts "c = #{c}"
  puts "d = #{d}"
  puts "block = #{yield(e)}"
end

all('test', 1 => 'cat', 2 => 'dog', *anArray, &aProc)

a = test
b = {1=>"cat", 2=>"dog"}
c = 98
d = [97, 96]
block = 99

Foo.Bar()         #  Methoden-Aufruf
Foo.Bar           #  Methoden-Aufruf
Foo::Bar()        #  Methoden-Aufruf
Foo::Bar          #  Zugriff auf Konstante

return [expr]*

super

super  [ ( [param]*[*array] ) ][block]

Operator-Methoden

expr1 operator
operator expr1
expr1 operator expr2

(expr1).operator(expr2)

Attribut-Zuweisung

receiver.attrname = rvalue

Element-Referenz-Operator

receiver [expr]+
receiver [expr]+ = rvalue

Aliasing

alias neuerNamealterName

Klassen-Definition

class classname[< superexpr]body
end

class << anObjectbody
end

• Bei Methoden-Definitionen wird die Methode in einer Tabelle im Klassen-Objekt registriert.
• Verschachtelte Klassen- und Modul-Definitionen werden innerhalb der Klasse in Konstanten gespeichert, nicht als globale Konstanten. Auf diese eingeschachtelten Klassen und Module kann von außerhalb der definierenden Klasse mit ``::'' zugegriffen werden.

  module NameSpace   class Example     CONST = 123   end end obj = NameSpace::Example.new a = NameSpace::Example::CONST

• Die Module#include-Methode fügt die angegebenen Module als anonyme Superklassen zur definierenden Klasse hinzu.

Objekt-Erzeugung durch Klassen

obj = classexpr.new [ ( [args]* ) ]

• erzeugt ein Objekt der Klasse der Empfängers (classexpr im Syntax-Beispiel).
• setzt den Typ des Objekts auf den des Empfängers.
• ruft die Instanz-Methode initialize in dem frisch erzeugten Objekt auf und übergibt ihm alle Argumente, die ursprünglich an new übergeben wurden.

Deklaration von Klassen-Attributen

class name
  attr attribute[, writable]
  attr_reader     [attribute]+
  attr_writer     [attribute]+
  attr_accessor   [attribute]+
end

Modul-Definitionen

module namebody
end

module Mod
  CONST = 1
  def Mod.method1    # module method
    CONST + 1
  end
end

Mixins --- Module einbinden

class|module name
  include expr
end

Modul-Funktionen

module Math
  def sin(x)
    #
  end
end

# Zugriff auf Math.sin nur über ...
include Math
sin(1)

module Math
  def sin(x)
    #
  end
  module_function :sin
end

Math.sin(1)
include Math
sin(1)

Zugriffs-Kontrolle

• Public. Zugriff für jeden.
• Protected. Kann nur aufgerufen werden von Objekten der definierenden Klasse oder Sub-Klassen.
• Private. Kann nur in funktionaler Form aufgerufen werden (das heißt über ein impizites self als Empfänger). Deshalb können private Methoden nur in der definierenden Klase und von direkten Nachkommen innerhalb des selben Objekts aufgerufen werden.

private    [aSymbol]*
protected  [aSymbol]*
public     [aSymbol]*

1. Ohne Argumente setzen die drei Funktionen die Standard-Zugriffs-Kontrolle für nachfolgend definierte Methoden.
2. Mit Argumenten setzen die Funktionen die Zugriffs-Kontrolle für die angegebenen Methoden und Konstanten.

Blöcke, Closures und Proc-Objekte

invocation  do  | a1, a2, ... |
end
invocation  {   | a1, a2, ... |
}

Proc-Objekte

Exceptions

Exceptions auslösen

raise
raise aString
raise thing[, aString[aStackTrace]]

Exception-Behandlung

  begin
    code...code...[rescue  [parm]*[=> var][then]error handling code...]*[else
    no exception code...][ensure
    always executed code...]
  end

Block-Wiederholung, Retry

Catch und Throw

catch ( aSymbol | aString )  do
  block...
end

throw( aSymbol | aString[, anObject] )