Die Klasse BasicObject ist seit Ruby 1.9 Rubys oberste Klasse und hat damit Object als solche abgelöst. BasicObject implementiert nur die allernotwendigsten Methoden und ist somit ein noch abstrakteres Ding als es ein Object schon war. Das führt unter anderem dazu, dass man es auch nicht gut in der irb betrachten kann:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
irb(main):001:0> x = BasicObject.new
NoMethodError: undefined method `inspect' for #<BasicObject:0x8b7a4a0>
from /opt/rubies/ruby-1.9.1-p243/lib/ruby/1.9.1/irb.rb:302:in `output_value'
from /opt/rubies/ruby-1.9.1-p243/lib/ruby/1.9.1/irb.rb:150:in `block (2 levels) in eval_input'
from /opt/rubies/ruby-1.9.1-p243/lib/ruby/1.9.1/irb.rb:263:in `signal_status'
from /opt/rubies/ruby-1.9.1-p243/lib/ruby/1.9.1/irb.rb:146:in `block in eval_input'
from /opt/rubies/ruby-1.9.1-p243/lib/ruby/1.9.1/irb/ruby-lex.rb:244:in `block (2 levels) in each_top_level_statement'
from /opt/rubies/ruby-1.9.1-p243/lib/ruby/1.9.1/irb/ruby-lex.rb:230:in `loop'
from /opt/rubies/ruby-1.9.1-p243/lib/ruby/1.9.1/irb/ruby-lex.rb:230:in `block in each_top_level_statement'
from /opt/rubies/ruby-1.9.1-p243/lib/ruby/1.9.1/irb/ruby-lex.rb:229:in `catch'
from /opt/rubies/ruby-1.9.1-p243/lib/ruby/1.9.1/irb/ruby-lex.rb:229:in `each_top_level_statement'
from /opt/rubies/ruby-1.9.1-p243/lib/ruby/1.9.1/irb.rb:145:in `eval_input'
from /opt/rubies/ruby-1.9.1-p243/lib/ruby/1.9.1/irb.rb:69:in `block in start'
from /opt/rubies/ruby-1.9.1-p243/lib/ruby/1.9.1/irb.rb:68:in `catch'
from /opt/rubies/ruby-1.9.1-p243/lib/ruby/1.9.1/irb.rb:68:in `start'
from /opt/rubies/ruby-1.9.1-p243/bin/irb:12:in `<main>'
Maybe IRB bug!!
irb(main):002:0> |
Aber die Funktionalität und Wichtigkeit von Object wird deswegen in keinster Weise eingeschränkt oder verdrängt, und vermutlich ist es als Neuling auch besser, nichts von der Existenz dieser Klasse zu wissen, da es verwirren kann. Neue Klassen werden nach wie vor standardmäßig von Object abgeleitet und so wird die neue Klasse kaum auffallen. Sie existiert vor allen Dingen für die (metaprogrammiertechnischen) Fälle, in denen ein absolutes BlankSlate-Objekt mit keinem Inhalt benötigt wird.
BasicObject mixt übrigens nicht einmal Kernel ein, sodass man auf die Methoden von Kernel nur per
zugreifen kann.
Instanzmethoden
!
| Anwendung
| !obj ==> true oder false
|
| Argumente
|
- obj: Das zu negierende Objekt.
|
| Beschreibung
| Negiert obj, d.h. kehrt true zu false um und false und nil zu true. Alle anderen Objekte werden zu false negiert.
|
| Rückgabewert
| true oder false, je nachdem.
|
| Beispiel
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
!true #=> false
!false #=> true
!nil #=> true
!3 #=> false
class A
#Das hier sollte man so nicht machen,
#denn dann hat eine Negierung quasi keinen
#Effekt mehr.
def !@
true
end
end
class B
end
x = A.new
y = B.new
!x #=> true
!y #=> false |
|
==
| Anwendung
| self == obj #=> true oder false
|
| Argumente
|
- obj: Das zu prüfende Objekt.
|
| Beschreibung
| Prüft auf Gleichheit. Diese Methode prüft auf Gleichheit der Objekt-ID, sie wird aber in der Regel von Subklassen überschrieben.
|
| Rückgabewert
| true oder false.
|
| Beispiel
|
1
2
3
4
5
6
7
|
x = BasicObject.new
y = BasicObject.new
p x == y #=> false
p x == x #=> true
a = "abc"
b = "abc"
p a == b #=> true |
|
!=
| Anwendung
| self != ( obj ) ==> true oder false
|
| Argumente
|
- obj: Das zu prüfende Objekt.
|
| Beschreibung
| Gibt genau das Gegenteil von == zurück.
|
| Rückgabewert
| true oder false, je nachdem.
|
| Beispiel
|
1
2
3
4
5
6
|
x = BasicObject.new
y = BasicObject.new
x == y #=> false
x != y #=> true
x == x #=> true
x != x #=> false |
|
equal?
Alias für ==.
initialize
| Anwendung
| Object.new
|
| Argumente
|
ab 1.9.3 standardmäßig keine, vorher *args
|
| Beschreibung
| Hook-Methode die aufgerufen wird wenn ein Objekt mit new erstellt wurde.
In 1.9.3 nimmt diese Methode standardmäßig keine Parameter an und muss für diesen Fall überschrieben werden.
|
| Rückgabewert
| Beim Aufruf von #new ist der Rückgabewert von initialize uninteressant.
|
| Beispiel
|
1
2
3
4
5
6
7
8
|
class Foo
attr_reader :var
def initialize(zahl)
@var = zahl
end
end
x = Foo.new(3)
x.var #=> 3 |
|
instance_eval
| Anwendung
| instance_eval( string [, name [, line ] ] ) ==> einObject
instance_eval{...} ==> einObject
|
| Argumente
|
- string: Der zu evaluierende String.
- name ("eval"): Der Name des evals in Fehlermeldungen
- line (1): Die Zeilennummer der ersten Zeile.
|
| Beschreibung
| Evaluiert string oder den angegebenen Block im Kontext des Aufrufers.
|
| Rückgabewert
| Der zuletzt ausgewertete Ausdruck des Blocks.
|
| Beispiel
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
class Foo
def initialize
@var = 3
end
end
x = Foo.new
x.var #=> NoMethodError
x.instance_eval{puts @var} #=> 3
class Bar
def initialize
@values = []
end
def add(val)
@values << val
end
def remove(val)
@values.delete_at(@values.index(val))
end
def operations(&block)
instance_eval(&block)
end
end
y = Bar.new
#Jede der innerhalb dieses Blocks aufgerufenen Methoden wird ausgeführt, als hätte dort y.methodenname gestanden.
y.operations do
add 2
add 4
add "xyz"
remove 2
end |
|
instance_exec
| Anwendung
| instance_exec(*obj){|*obj| ...} ==> einObject
|
| Argumente
|
- *obj: Zu übergebende Argumente.
|
| Beschreibung
| Im Prinzip das Gleiche wie instance_eval, aber die der Methode mitgegebenen Argumente werden in den Block als Blockargumente gegeben.
|
| Rückgabewert
| Der Wert des letzten ausgeführten Ausdrucks.
|
| Beispiel
|
|
method_missing
| Anwendung
| method_missing( sym [, *obj [ , &block ] ] ) ==> einObject
|
| Argumente
|
- sym: Das Symbol der nicht gefundenen Methode
- *obj: Die Argumente für die nicht gefundene Methode
- &block: Der der nicht gefundenen Methode übergebene Block.
|
| Beschreibung
| Eine Hook-Methode, die immer dann aufgerufen wird, wenn eine Methode nicht bei einem Objekt gefunden wurde. Die standardmäßige Implementierung sieht das Werfen eines NoMethodErrors vor, aber dieses Verhalten kann überschrieben werden.
|
| Rückgabewert
| Der letzte Ausdruck in der Methode.
|
| Beispiel
|
|
"ruby".gibtsnich #=> NoMethodError |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
class Roman
def roman_to_int
#Code...
end
def method_missing(name, *args, &block)
super if !args.empty? or block
roman_to_int(name.to_s)
end
end
r = Roman.new
r.iv #=> 4
r.xxiii #=> 23
r.mm #=> 2000 |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class MyDelegator
def initialize(an_object)
@object = an_object
end
def method_missing(name, *args, &block)
@object.send(name, *args, &block)
end
end
d = MyDelegator.new(10)
puts(d / 2) #=> 5 |
|
__send__
| Anwendung
| __send__( sym [, *args ] ) ==> einObject
__send__( sym [, *args ] [, &block ] ) ==> einObject
__send__( sym [, *args ] ){...} ==> einObject
|
| Argumente
|
- sym: Das Symbol der Methode.
- *args ([]): Die zu übergebenden Argumente.
- &block bzw. Blockform: Zu übergebender Block.
|
| Beschreibung
| Sendet dem Aufrufer die Nachricht, eine bestimmte Methode auszuführen. Der Alias send wird erst in Object definiert. BasicObject mixt Kernel noch nicht ein, sodass zum Aufruf von Methoden aus dem Kernel-Modul ein bisschen Trickserei erforderlich ist (siehe Beispiel).
|
| Rückgabewert
| Was immer die aufgerufene Methode zurückgibt.
|
| Beispiel
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class Foo < BasicObject
def bar(*args)
yield if ::Kernel.block_given?
::Kernel.puts "Argumente: #{args.join(", ")}"
end
end
x = Foo.new
x.bar("A")
x.__send__(:bar, "A")
x.__send__(:bar)
x.__send__(:bar, "A", "B"){puts "Block"} |
Output:
1
2
3
4
5
|
Argumente: A
Argumente: A
Argumente:
Block
Argumente: A, B |
|
