Programmierung in Ruby

Der Leitfaden der Pragmatischen Programmierer
class Object
Parent:
Version: 1.6

Index:

== === =~ __id__ __send__ class clone display dup eql? equal? extend freeze frozen? hash id inspect instance_eval instance_of? instance_variables is_a? kind_of? method method_missing methods nil? private_methods protected_methods public_methods respond_to? send singleton_methods taint tainted? to_a to_s type untaint


Subclasses: Array, Binding, Continuation, Data, Dir, Exception, FalseClass, File::Stat, Hash, IO, MatchingData, Method, Module, NilClass, Numeric, Proc, Range, Regexp, String, Struct, Symbol, Thread, Time, TrueClass

Object ist die Oberklasse aller Klassen in Ruby. Seine Methoden stehen daher für alle Objekte zur Verfügung, ausser sie werden ausdrücklich überladen.

Object bindet das Kernel-Modul ein, so dass die eingebauten Kernelfunktionen global verfügbar sind. Obwohl die Instanzmethoden von Object durch das Kernel-Module definiert werden, haben wir uns entschlossen, diese aus Gründen der Übersichtlichkeit hier zu dokumentieren.

In den folgenden Beschreibungen bezeichnet der Parameter einSymbol entweder einen String (in Anführungszeichen) oder ein Symbol (wie z.B. :name).

instance methods
== obj == einObjekt-> true oder false

Gleichheit---Auf dem Objekt-Level gibt ==true zurück, wenn obj und einObjekt das selbe Objekt sind. Diese Methode wird in abgeleiteten Klassen typischerweise überschrieben, um eine Klassen-spezifische Bedeutung einzubringen.

=== obj === einObjekt-> true oder false

Fallgleichheit---Synonym für Object#==. Jedoch wird auch diese Methode durch abgeleitete Klassen typischerweise überschrieben, um eine sinnvolle Semantik in case-Anweisungen zu ermöglichen.

=~ obj =~ einObjekt-> false

Mustervergleich---Wird durch abgeleitete Klassen überschrieben (insbesondere bei Regexp und String) um sinnvolle Mustervergleichs-Semantik zu erhalten.

__id__ obj.__id__ -> eineFixnum

Synonym für Object#id.

__send__ obj.__send__( einSymbol[, args]+ ) -> einObjekt

Synonym für Object#send.

class obj.class -> eineKlasse

Gibt die Klasse von obj zurück (synonym für Object#type).

clone obj.clone -> einObjekt

Erstellt eine flache Kopie von obj---es werden nur die Instanzvariablen von obj kopiert, jedoch nicht die durch sie referenzierten Objekte. Kopiert eingefrorene und ``tainted'' Zustände von obj. Vgl. auch die Diskussion bei Object#dup.

class Klass
   attr_accessor :str
end
s1 = Klass.new » #<Klass:0x4018d234>
s1.str = "Hello" » "Hello"
s2 = s1.clone » #<Klass:0x4018d194  @str="Hello">
s2.str[1,4] = "i" » "i"
s1.inspect » "#<Klass:0x4018d234  @str=\"Hi\">"
s2.inspect » "#<Klass:0x4018d194  @str=\"Hi\">"

display obj.display( port=$> ) -> nil

Gibt obj am angegebenen Port aus (Standardeinstellung für den Port ist $>). Equivalent mit: 

def display(port=$>)
  port.write self
end

dup obj.dup -> einObjekt

Erstellt eine flache Kopie von obj---es werden die Instanzvariablen von obj kopiert, jedoch nicht die durch sie referenzierten Objekte. dup kopiert den ``tainted''-Status von obj. Vgl. auch Kapitel ``Ruby im Tresor sichern'' sowie die Diskussion bei Object#clone. Generell stehen clone und dup für verschiedene semantische Kontexte in abgeleiteten Klassen. Während clone angesprochen wird, um ein Objekt mitsamt seinem internen Zustand zu duplizieren, verwendet dup typischerweise die Klasse des abgleiteten Objekts um eine neue Instanz zu erstellen.

eql? obj.eql?( einObjekt ) -> true oder false

Gibt true zurück, wenn obj und einObjekt denselben Wert haben. Wird von Hash benutzt, um Elemente auf Gleichheit zu prüfen. Für Objekte der Klasse Object ist eql? synonym zu ==. Unterklassen setzten diese Tradition normalerweise fort, jedoch gibt es Ausnahmen. Zum Beispiel führen Numeric-Typen eine Typkonversion zwar über == aus, jedoch nicht über eql?, so dass:

1 == 1.0 » true
1.eql? 1.0 » false

equal? obj.equal?( einObjekt ) -> true oder false

Gibt true zurück, wenn obj und einObjekt dieselbe Objekt ID besitzen. Diese Methode sollte durch Unterklassen nicht überschrieben werden.

a = [ 'cat', 'dog' ]
b = [ 'cat', 'dog' ]
a == b » true
a.id == b.id » false
a.eql?(b) » true
a.equal?(b) » false

extend obj.extend( [einModul]+ ) -> obj

Fügt die Instanzmethoden jedes als Parameter übergebenen Moduls zu obj hinzu.

module Mod
  def hello
    "Hello from Mod.\n"
  end
end
class Klass
  def hello
    "Hello from Klass.\n"
  end
end
k = Klass.new
k.hello » "Hello from Klass.\n"
k.extend(Mod) » #<Klass:0x4018d414>
k.hello » "Hello from Mod.\n"

freeze obj.freeze -> obj

Verhindert weitere Modifikationen an obj. Bei dem Versuch wird ein TypeError geworfen. Ein eingefrorenes Objekt kann nicht wieder ``aufgetaut'' werden. Siehe auch Object#frozen?. 

a = [ "a", "b", "c" ]
a.freeze
a << "z"
ergibt:
prog.rb:3:in `<<': can't modify frozen array (TypeError)
	from prog.rb:3

frozen? obj.frozen? -> true oder false

Gibt den Einfrierstatus von obj zurück.

a = [ "a", "b", "c" ]
a.freeze » ["a", "b", "c"]
a.frozen? » true

hash obj.hash -> eineFixnum

Generiert einen Fixnum Hash-Wert für dieses Objekt. Diese Funktion muss die Eigenschaft a.eql?(b) impliziert a.hash == b.hash besitzen. Der Hash-Wert wird von Hash benutzt. Jeder Hash-Wert, der den Zahlenraum einer Fixnum übersteigt, wird vor der Benutzung abgeschnitten.

id obj.id -> eineFixnum

Gibt eine ganzzahlige Kennung für obj zurück. Jeder Aufruf von id gibt für ein gegebenes Objekt dieselbe Kennung wieder. Zwei aktive Objekte können nicht dieselbe Kennung besitzen. Das Konzept der Object#id weicht von der :name-Notation, die die Symbol-ID von name zurück gibt, ab.

inspect obj.inspect -> einString

Gibt einen String zurück, der eine menschenlesbare Repräsentation von obj zurück gibt. Falls die Methode nicht überschrieben wurde, wird to_s genutzt, um den String zu erstellen.

[ 1, 2, 3..4, 'five' ].inspect » "[1, 2, 3..4, \"five\"]"
Time.new.inspect » "Sun Mar 04 23:29:19 CST 2001"

instance_eval obj.instance_eval(einString[, datei[zeile]] ) -> einObjekt
obj.instance_eval {| | block }-> einObjekt

Evaluiert einen String, der Ruby-Quellcode enthält, bzw. den angegebenen Codeblock im Kontext des Empfängers (hier obj). Um den Kontext zu setzen, erhält self für die Dauer der Ausführung den Wert obj, wodurch der Code auf die Instanzvariablen von obj zugreifen kann. In der Version von instance_eval, die einen String zur Ausführung erhält, können mit den optionalen Parametern datei und zeile ein Dateinamen sowie die Anfangszeile angegeben werden, die für die Ausgabe von Compile-Fehlern verwendet werden.

class Klass
  def initialize
    @secret = 99
  end
end
k = Klass.new
k.instance_eval { @secret } » 99

instance_of? obj.instance_of?( eineKlasse ) -> true oder false

Gibt true zurück, wenn obj eine Instanz der angegebenen Klasse ist. Siehe auch Object#kind_of?.

instance_variables obj.instance_variables -> einArray

Gibt ein Array mit den Instanzvariablennamen des Empfängers zurück.

is_a? obj.is_a?( eineKlasse ) -> true oder false

Synonym für Object#kind_of?.

kind_of? obj.kind_of?( eineKlasse ) -> true oder false
Gibt true zurück, wenn obj vom Typ eineKlasse ist bzw. wenn eineKlasse eine Oberklasse von obj oder ein in obj eingebundenes Modul ist.

a = Integer.new
a.instance_of? Numeric » false
a.instance_of? Integer » true
a.instance_of? Fixnum » false
a.instance_of? Comparable » false
a.kind_of? Numeric » true
a.kind_of? Integer » true
a.kind_of? Fixnum » false
a.kind_of? Comparable » true

method obj.method( einSymbol ) -> eineMethode

Sucht die genannte Methode als Empfänger in obj und gibt ein entsprechendes Method-Objekt zurück (bzw. wirft einen NameError). Das Method-Objekt bewirkt eine Schließung der Objektinstanz in obj, so dass die Instanzvariablen und der Wert von self erhalten bleiben.

class Demo
  def initialize(n)
    @iv = n
  end
  def hello()
    "Hello, @iv = [email protected]}"
  end
end
k = Demo.new(99)
m = k.method(:hello)
m.call » "Hello, @iv = 99"
l = Demo.new('Fred')
m = l.method("hello")
m.call » "Hello, @iv = Fred"

method_missing obj.method_missing( einSymbol[, *args] ) -> einObjekt
Wird von Ruby aufgerufen, wenn obj einen Aufruf erhält, den es nicht verarbeiten kann. einSymbol ist das Symbol der aufgerufenen Methode und args sind etwaige übergebene Argumente. Das unten gezeigte Beispiel erstellt eine Klasse Roman, die Methodenaufrufe in der Form römischer Ziffern durch Ausgabe der entsprechenden Ganzzahl beantwortet. 

class Roman
  def romanToInt(str)
    # ...
  end
  def method_missing(methId)
    str = methId.id2name
    romanToInt(str)
  end
end

r = Roman.new
r.iv » 4
r.xxiii » 23
r.mm » 2000

methods obj.methods -> einArray

Gibt eine Liste der öffentlich zugänglichen Methoden in obj zurück. Die öffentlichen Methoden der Vorfahren von obj sind eingeschlossen.

class Klass
  def kMethod()
  end
end
k = Klass.new
k.methods[0..9] » ["kMethod", "instance_of?", "protected_methods",
"inspect", "freeze", "dup", "__id__", "equal?",
"send", "=="]
k.methods.length » 38

nil? obj.nil? -> true oder false

Alle Objekte ausser nil geben hier false zurück.

private_methods obj.private_methods -> einArray

Gibt eine Liste der privat zugänglichen Methoden in obj zurück. Die privaten Methoden der Vorfahren von obj werden ebenso mitgegeben wie Methoden aus den eventuelle eingebundenen Modulen.

protected_methods obj.protected_methods -> einArray

Gibt eine Liste der geschützten Methoden in obj zurück.

public_methods obj.public_methods -> einArray

Synonym für Object#methods.

respond_to? obj.respond_to?( einSymbol, schliessePrivEin=false ) -> true oder false

Gibt true zurück, wenn obj den angegebenen Aufruf beantwortet. Private Methoden werden nur in die Suche eingeschlossen, wenn im optionalen zweiten Parameter true steht.

send obj.send( einSymbol[, args]* ) -> einObjekt

Ruft die mit einSymbol bezeichnete Methode auf und übergibt ihr etwaige Argumente. Es kann auch __send__ verwendet werden, wenn der Name send mit einer bestehenden Methode in obj kollidiert.

class Klass
  def hello(*args)
    "Hello " + args.join(' ')
  end
end
k = Klass.new
k.send :hello, "gentle", "readers" » "Hello gentle readers"

singleton_methods obj.singleton_methods -> einArray

Gibt ein Array mit allen Singletonmethoden in obj zurück.

class Klass
  def Klass.classMethod
  end
end
k = Klass.new
def k.sm()
end
Klass.singleton_methods » ["classMethod"]
k.singleton_methods » ["sm"]

taint obj.taint -> obj

Markiert obj als ``tainted'' (vgl. Kapitel 20 ``Ruby im Tresor sichern'').

tainted? obj.tainted? -> true oder false

Gibt true zurück, wenn das Objekt ``tainted'' ist (vgl. Kapitel 20 ``Ruby im Tresor sichern'').

to_a obj.to_a -> einArray

Gibt eine Array-Repräsentation von obj zurück. Objekte der Klasse Object und andere, die die Klasse nicht ausdrücklich überschreiben, ist der Rückgabewert ein Array, das self enthält.

self.to_a » [main]
"hello".to_a » ["hello"]
Time.new.to_a » [19, 29, 23, 4, 3, 2001, 0, 63, false, "CST"]

to_s obj.to_s -> einString

Gibt einen String mit der Zeichendarstellung von obj zurück. Die Standardmethode to_s gibt die Klasse sowie eine Kodierung der Objekt-ID zurück. Ein Spezialfall ist das Top-level Objekt, das den initialen Ausführungskontext von Ruby darstellt: Hier wird ``main'' ausgegeben.

type obj.type -> eineKlasse

Gibt die Klasse von obj zurück. Equivalent zu class.

untaint obj.untaint -> obj

Entfernt die Markierung als ``tainted'' aus obj (vgl. Kapitel 20 ``Ruby im Tresor sichern'').

Extracted from the book "Programming Ruby - The Pragmatic Programmer's Guide"
Übersetzung: Carsten Schinzer
Für das englische Original:
© 2000 Addison Wesley Longman, Inc. Released under the terms of the Open Publication License V1.0. That reference is available for download.
Diese Lizenz sowie das Original vom Herbst 2001 bilden die Grundlage der Übersetzung
Es wird darauf hingewiesen, dass sich die Lizenz des englischen Originals inzwischen geändert hat.
Für die deutsche Übersetzung:
© 2002 Jürgen Katins
Der Copyright-Eigner stellt folgende Lizenzen zur Verfügung:
Nicht-freie Lizenz:
This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v1.0 or later (the latest version is presently available at http://www.opencontent.org/openpub/). Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder. Distribution of the work or derivative of the work in any standard (paper) book form is prohibited unless prior permission is obtained from the copyright holder.
Freie Lizenz:
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with no Invariant Sections, with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License".