class Object

Gibt true zurück, wenn zwei Objekte nicht übereinstimmen (unter Verwendung der =~-Methode), andernfalls false.

Vergleicht self und other.

Gibt zurück

• 0, wenn self und other dasselbe Objekt sind oder wenn self == other.

• nil, andernfalls.

Beispiele

o = Object.new
o <=> o     # => 0
o <=> o.dup # => nil

Eine Klasse, die das Modul Comparable einbindet, sollte diese Methode durch Definition einer Instanzmethode überschreiben, die

• Nimmt ein Argument, other.

• Gibt zurück

  • -1, wenn self kleiner als other ist.

  • 0, wenn self gleich other ist.

  • 1, wenn self größer als other ist.

  • nil, wenn die beiden Werte unvergleichlich sind.

Gibt true oder false zurück.

Wie Object#==, wenn object eine Instanz von Object ist (und nicht eine Instanz einer seiner vielen Unterklassen).

Diese Methode wird von diesen Unterklassen häufig überschrieben, um eine aussagekräftige Semantik in case-Anweisungen bereitzustellen.

Die primäre Schnittstelle zu dieser Bibliothek. Wird verwendet, um die Delegation beim Definieren Ihrer Klasse einzurichten.

class MyClass < DelegateClass(ClassToDelegateTo) # Step 1
  def initialize
    super(obj_of_ClassToDelegateTo)              # Step 2
  end
end

oder

MyClass = DelegateClass(ClassToDelegateTo) do    # Step 1
  def initialize
    super(obj_of_ClassToDelegateTo)              # Step 2
  end
end

Hier ist ein Beispiel für die Verwendung von Tempfile, das eigentlich ein File-Objekt ist mit einigen speziellen Regeln bezüglich des Speicherorts und wann die File gelöscht werden soll. Das ist ein fast lehrbuchmäßiges Beispiel dafür, wie Delegation verwendet wird.

class Tempfile < DelegateClass(File)
  # constant and class member data initialization...

  def initialize(basename, tmpdir=Dir::tmpdir)
    # build up file path/name in var tmpname...

    @tmpfile = File.open(tmpname, File::RDWR|File::CREAT|File::EXCL, 0600)

    # ...

    super(@tmpfile)

    # below this point, all methods of File are supported...
  end

  # ...
end

Gibt eine Digest-Unterklasse nach name auf threadsichere Weise zurück, auch wenn das On-Demand-Laden involviert ist.

require 'digest'

Digest("MD5")
# => Digest::MD5

Digest(:SHA256)
# => Digest::SHA256

Digest(:Foo)
# => LoadError: library not found for class Digest::Foo -- digest/foo

Definiert eine öffentliche Singleton-Methode im Empfänger. Der Parameter method kann ein Proc, ein Method oder ein UnboundMethod-Objekt sein. Wenn ein Block angegeben ist, wird er als Methodenrumpf verwendet. Wenn ein Block oder eine Methode Parameter hat, werden diese als Methodenparameter verwendet.

class A
  class << self
    def class_name
      to_s
    end
  end
end
A.define_singleton_method(:who_am_i) do
  "I am: #{class_name}"
end
A.who_am_i   # ==> "I am: A"

guy = "Bob"
guy.define_singleton_method(:hello) { "#{self}: Hello there!" }
guy.hello    #=>  "Bob: Hello there!"

chris = "Chris"
chris.define_singleton_method(:greet) {|greeting| "#{greeting}, I'm Chris!" }
chris.greet("Hi") #=> "Hi, I'm Chris!"

Schreibt self in den gegebenen Port

1.display
"cat".display
[ 4, 5, 6 ].display
puts

Ausgabe

1cat[4, 5, 6]

Erzeugt eine flache Kopie von obj – die Instanzvariablen von obj werden kopiert, aber nicht die Objekte, auf die sie verweisen.

Diese Methode kann klassenspezifisches Verhalten aufweisen. In diesem Fall wird dieses Verhalten unter der Methode #initialize_copy der Klasse dokumentiert.

zu dup im Vergleich zu clone

Im Allgemeinen können clone und dup in abgeleiteten Klassen unterschiedliche Semantik haben. Während clone zum Duplizieren eines Objekts, einschließlich seines internen Zustands, verwendet wird, verwendet dup typischerweise die Klasse des abgeleiteten Objekts, um die neue Instanz zu erstellen.

Bei der Verwendung von dup werden keine Module kopiert, mit denen das Objekt erweitert wurde.

class Klass
  attr_accessor :str
end

module Foo
  def foo; 'foo'; end
end

s1 = Klass.new #=> #<Klass:0x401b3a38>
s1.extend(Foo) #=> #<Klass:0x401b3a38>
s1.foo #=> "foo"

s2 = s1.clone #=> #<Klass:0x401be280>
s2.foo #=> "foo"

s3 = s1.dup #=> #<Klass:0x401c1084>
s3.foo #=> NoMethodError: undefined method `foo' for #<Klass:0x401c1084>

Gleichheit — Auf der Ebene von Object gibt == nur true zurück, wenn obj und other dasselbe Objekt sind. Typischerweise wird diese Methode in abgeleiteten Klassen überschrieben, um klassenspezifische Bedeutungen bereitzustellen.

Im Gegensatz zu == sollte die Methode equal? niemals von Unterklassen überschrieben werden, da sie zur Bestimmung der Objektidentität verwendet wird (d. h., a.equal?(b) gilt genau dann, wenn a dasselbe Objekt wie b ist).

obj = "a"
other = obj.dup

obj == other      #=> true
obj.equal? other  #=> false
obj.equal? obj    #=> true

Die Methode eql? gibt true zurück, wenn obj und other denselben Hash-Schlüssel referenzieren. Dies wird von Hash verwendet, um Mitglieder auf Gleichheit zu testen. Für jedes Paar von Objekten, für das eql? true zurückgibt, muss der hash-Wert beider Objekte gleich sein. Jede Unterklasse, die eql? überschreibt, sollte daher auch hash entsprechend überschreiben.

Für Objekte der Klasse Object ist eql? synonym mit ==. Unterklassen setzen diese Tradition normalerweise fort, indem sie eql? an ihre überschriebene ==-Methode anbinden, aber es gibt Ausnahmen. Numeric-Typen führen beispielsweise Typkonvertierungen über == durch, aber nicht über eql?, daher

1 == 1.0     #=> true
1.eql? 1.0   #=> false

Fügt obj die Instanzmethoden aus jedem als Parameter angegebenen Modul 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:0x401b3bc8>
k.hello         #=> "Hello from Mod.\n"

Verhindert weitere Änderungen an obj. Bei einem Änderungsversuch wird ein FrozenError ausgelöst. Es gibt keine Möglichkeit, ein gefrorenes Objekt aufzutauen. Siehe auch Object#frozen?.

Diese Methode gibt self zurück.

a = [ "a", "b", "c" ]
a.freeze
a << "z"

ergibt

prog.rb:3:in `<<': can't modify frozen Array (FrozenError)
 from prog.rb:3

Objekte der folgenden Klassen sind immer gefroren: Integer, Float, Symbol.

Gibt den ganzzahligen Hash-Wert für self zurück; hat die Eigenschaft, dass, wenn foo.eql?(bar) gilt, dann foo.hash == bar.hash.

Die Klasse Hash verwendet sowohl hash als auch eql?, um zu bestimmen, ob zwei als Hash-Schlüssel verwendete Objekte als derselbe Schlüssel behandelt werden sollen. Ein Hash-Wert, der die Kapazität eines Integer überschreitet, wird vor der Verwendung abgeschnitten.

Viele Kernklassen überschreiben die Methode Object#hash; andere Kernklassen (z. B. Integer) berechnen den Hash intern und rufen die Methode hash nicht auf, wenn sie als Hash-Schlüssel verwendet werden.

Beim Implementieren von hash für eine benutzerdefinierte Klasse ist es bewährte Praxis, Array#hash mit dem Klassennamen und den Werten zu verwenden, die in der Instanz wichtig sind; dies nutzt die Logik dieser Methode zur sicheren und effizienten Erzeugung eines Hash-Werts.

def hash
  [self.class, a, b, c].hash
end

Der Hash-Wert kann zwischen Aufrufen oder Implementierungen von Ruby variieren. Wenn Sie stabile Hash-ähnliche Bezeichner über Ruby-Aufrufe und -Implementierungen hinweg benötigen, verwenden Sie eine benutzerdefinierte Methode, um diese zu generieren.

Gibt einen String zurück, der eine menschenlesbare Darstellung von obj enthält. Der Standard-inspect zeigt den Klassennamen des Objekts, eine Kodierung seiner Speicheradresse und eine Liste der Instanzvariablen und ihrer Werte an (durch Aufrufen von inspect für jede davon). Vom Benutzer definierte Klassen sollten diese Methode überschreiben, um eine bessere Darstellung von obj zu liefern. Beim Überschreiben dieser Methode sollte ein String zurückgegeben werden, dessen Kodierung mit der externen Standardkodierung kompatibel ist.

[ 1, 2, 3..4, 'five' ].inspect   #=> "[1, 2, 3..4, \"five\"]"
Time.new.inspect                 #=> "2008-03-08 19:43:39 +0900"

class Foo
end
Foo.new.inspect                  #=> "#<Foo:0x0300c868>"

class Bar
  def initialize
    @bar = 1
  end
end
Bar.new.inspect                  #=> "#<Bar:0x0300c868 @bar=1>"

Wenn obj auf instance_variables_to_inspect reagiert, werden nur die in der zurückgegebenen Array aufgeführten Instanzvariablen in den Inspect-String aufgenommen.

class DatabaseConfig
  def initialize(host, user, password)
    @host = host
    @user = user
    @password = password
  end

private
  def instance_variables_to_inspect = [:@host, :@user]
end

conf = DatabaseConfig.new("localhost", "root", "hunter2")
conf.inspect #=> #<DatabaseConfig:0x0000000104def350 @host="localhost", @user="root">

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

class A;     end
class B < A; end
class C < B; end

b = B.new
b.instance_of? A   #=> false
b.instance_of? B   #=> true
b.instance_of? C   #=> false

Gibt true zurück, wenn die gegebene Instanzvariable in obj definiert ist. String-Argumente werden in Symbole konvertiert.

class Fred
  def initialize(p1, p2)
    @a, @b = p1, p2
  end
end
fred = Fred.new('cat', 99)
fred.instance_variable_defined?(:@a)    #=> true
fred.instance_variable_defined?("@b")   #=> true
fred.instance_variable_defined?("@c")   #=> false

Gibt den Wert der gegebenen Instanzvariable zurück, oder nil, wenn die Instanzvariable nicht gesetzt ist. Der Teil @ des Variablennamens sollte für reguläre Instanzvariablen enthalten sein. Löst eine NameError-Ausnahme aus, wenn das angegebene Symbol nicht als Instanzvariablenname gültig ist. String-Argumente werden in Symbole konvertiert.

class Fred
  def initialize(p1, p2)
    @a, @b = p1, p2
  end
end
fred = Fred.new('cat', 99)
fred.instance_variable_get(:@a)    #=> "cat"
fred.instance_variable_get("@b")   #=> 99

Setzt die Instanzvariable mit dem Namen symbol auf das gegebene Objekt. Dies kann die vom Autor der Klasse beabsichtigte Kapselung umgehen, daher sollte sie mit Vorsicht verwendet werden. Die Variable muss vor diesem Aufruf nicht vorhanden sein. Wenn der Name der Instanzvariable als String übergeben wird, wird dieser String in ein Symbol konvertiert.

class Fred
  def initialize(p1, p2)
    @a, @b = p1, p2
  end
end
fred = Fred.new('cat', 99)
fred.instance_variable_set(:@a, 'dog')   #=> "dog"
fred.instance_variable_set(:@c, 'cat')   #=> "cat"
fred.inspect                             #=> "#<Fred:0x401b3da8 @a=\"dog\", @b=99, @c=\"cat\">"

Gibt ein Array von Instanzvariablennamen für den Empfänger zurück. Beachten Sie, dass die bloße Definition eines Accessors nicht die entsprechende Instanzvariable erstellt.

class Fred
  attr_accessor :a1
  def initialize
    @iv = 3
  end
end
Fred.new.instance_variables   #=> [:@iv]

Gibt den Empfänger zurück.

string = "my string"
string.itself.object_id == string.object_id   #=> true

Gibt true zurück, wenn class die Klasse von obj ist, oder wenn class eine der Oberklassen von obj oder in obj enthaltene Module ist.

module M;    end
class A
  include M
end
class B < A; end
class C < B; end

b = B.new
b.is_a? A          #=> true
b.is_a? B          #=> true
b.is_a? C          #=> false
b.is_a? M          #=> true

b.kind_of? A       #=> true
b.kind_of? B       #=> true
b.kind_of? C       #=> false
b.kind_of? M       #=> true

Sucht die benannte Methode als Empfänger in obj und gibt ein Method-Objekt zurück (oder löst NameError aus). Das Method-Objekt fungiert als Closure in der Objektinstanz von obj, sodass Instanzvariablen und der Wert von self weiterhin verfügbar bleiben.

class Demo
  def initialize(n)
    @iv = n
  end
  def hello()
    "Hello, @iv = #{@iv}"
  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"

Beachten Sie, dass Method die Methode to_proc implementiert, was bedeutet, dass sie mit Iteratoren verwendet werden kann.

[ 1, 2, 3 ].each(&method(:puts)) # => prints 3 lines to stdout

out = File.open('test.txt', 'w')
[ 1, 2, 3 ].each(&out.method(:puts)) # => prints 3 lines to file

require 'date'
%w[2017-03-01 2017-03-02].collect(&Date.method(:parse))
#=> [#<Date: 2017-03-01 ((2457814j,0s,0n),+0s,2299161j)>, #<Date: 2017-03-02 ((2457815j,0s,0n),+0s,2299161j)>]

Gibt eine Liste der Namen von öffentlichen und geschützten Methoden von obj zurück. Dies umfasst alle Methoden, die in den Vorfahren von obj zugänglich sind. Wenn der optionale Parameter false ist, wird ein Array von öffentlichen und geschützten Singleton-Methoden von obj zurückgegeben, das keine Methoden in Modulen enthält, die in obj eingebunden sind.

class Klass
  def klass_method()
  end
end
k = Klass.new
k.methods[0..9]    #=> [:klass_method, :nil?, :===,
                   #    :==~, :!, :eql?
                   #    :hash, :<=>, :class, :singleton_class]
k.methods.length   #=> 56

k.methods(false)   #=> []
def k.singleton_method; end
k.methods(false)   #=> [:singleton_method]

module M123; def m123; end end
k.extend M123
k.methods(false)   #=> [:singleton_method]

Nur das Objekt nil antwortet true auf nil?.

Object.new.nil?   #=> false
nil.nil?          #=> true

Gibt eine ganzzahlige Kennung für obj zurück.

Dieselbe Zahl wird bei allen Aufrufen von object_id für ein gegebenes Objekt zurückgegeben, und keine zwei aktiven Objekte teilen sich eine ID.

Hinweis: Einige Objekte von integrierten Klassen werden zu Optimierungszwecken wiederverwendet. Dies ist bei unmittelbaren Werten und gefrorenen String-Literalen der Fall.

BasicObject implementiert __id__, Kernel implementiert object_id.

Unmittelbare Werte werden nicht per Referenz, sondern per Wert übergeben: nil, true, false, Fixnums, Symbole und einige Floats.

Object.new.object_id  == Object.new.object_id  # => false
(21 * 2).object_id    == (21 * 2).object_id    # => true
"hello".object_id     == "hello".object_id     # => false
"hi".freeze.object_id == "hi".freeze.object_id # => true

Gibt die Liste der privaten Methoden zurück, auf die obj zugreifen kann. Wenn der Parameter all auf false gesetzt ist, werden nur die Methoden im Empfänger aufgeführt.

Gibt die Liste der geschützten Methoden zurück, auf die obj zugreifen kann. Wenn der Parameter all auf false gesetzt ist, werden nur die Methoden im Empfänger aufgeführt.

Ähnlich wie method, sucht nur nach öffentlichen Methoden.

Gibt die Liste der öffentlichen Methoden zurück, auf die obj zugreifen kann. Wenn der Parameter all auf false gesetzt ist, werden nur die Methoden im Empfänger aufgeführt.

Ruft die durch symbol identifizierte Methode auf und übergibt ihr alle angegebenen Argumente. Im Gegensatz zu send ruft public_send nur öffentliche Methoden auf. Wenn die Methode durch einen String identifiziert wird, wird der String in ein Symbol konvertiert.

1.public_send(:puts, "hello")  # causes NoMethodError

Entfernt die benannte Instanzvariable aus obj und gibt den Wert dieser Variable zurück. Der Name kann als Symbol oder als String übergeben werden.

class Dummy
  attr_reader :var
  def initialize
    @var = 99
  end
  def remove
    remove_instance_variable(:@var)
  end
end
d = Dummy.new
d.var      #=> 99
d.remove   #=> 99
d.var      #=> nil

Gibt true zurück, wenn obj auf die gegebene Methode reagiert. Private und geschützte Methoden werden nur dann in die Suche einbezogen, wenn der optionale zweite Parameter zu true ausgewertet wird.

Wenn die Methode nicht implementiert ist, wie z. B. Process.fork unter Windows, File.lchmod unter GNU/Linux usw., wird false zurückgegeben.

Wenn die Methode nicht definiert ist, wird die Methode respond_to_missing? aufgerufen und das Ergebnis zurückgegeben.

Wenn der Methodenname als String übergeben wird, wird der String in ein Symbol konvertiert.

NICHT DIREKT VERWENDEN.

Hook-Methode, um zurückzugeben, ob obj auf die Methode id reagieren kann oder nicht.

Wenn der Methodenname als String übergeben wird, wird der String in ein Symbol konvertiert.

Siehe respond_to? und das Beispiel von BasicObject.

Ruft die durch symbol identifizierte Methode auf und übergibt ihr alle angegebenen Argumente. Wenn die Methode durch einen String identifiziert wird, wird der String in ein Symbol konvertiert.

BasicObject implementiert __send__, Kernel implementiert send. __send__ ist sicherer als send, wenn obj denselben Methodennamen wie Socket hat. Siehe auch public_send.

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

Gibt die Singleton-Klasse von obj zurück. Diese Methode erstellt eine neue Singleton-Klasse, wenn obj keine hat.

Wenn obj nil, true oder false ist, gibt sie NilClass, TrueClass bzw. FalseClass zurück. Wenn obj eine Integer, ein Float oder ein Symbol ist, löst sie einen TypeError aus.

Object.new.singleton_class  #=> #<Class:#<Object:0xb7ce1e24>>
String.singleton_class      #=> #<Class:String>
nil.singleton_class         #=> NilClass

Ähnlich wie method, sucht nur nach Singleton-Methoden.

class Demo
  def initialize(n)
    @iv = n
  end
  def hello()
    "Hello, @iv = #{@iv}"
  end
end

k = Demo.new(99)
def k.hi
  "Hi, @iv = #{@iv}"
end
m = k.singleton_method(:hi)
m.call   #=> "Hi, @iv = 99"
m = k.singleton_method(:hello) #=> NameError

Gibt ein Array der Namen von Singleton-Methoden für obj zurück. Wenn der optionale Parameter all wahr ist, enthält die Liste Methoden in Modulen, die in obj eingebunden sind. Es werden nur öffentliche und geschützte Singleton-Methoden zurückgegeben.

module Other
  def three() end
end

class Single
  def Single.four() end
end

a = Single.new

def a.one()
end

class << a
  include Other
  def two()
  end
end

Single.singleton_methods    #=> [:four]
a.singleton_methods(false)  #=> [:two, :one]
a.singleton_methods         #=> [:two, :one, :three]

Erstellt einen neuen Enumerator, der durch Aufrufen von method auf obj mit den gegebenen args (falls vorhanden) enumeriert. Was von der Methode *yielded* wurde, werden die Werte des Enumerators.

Wenn ein Block gegeben ist, wird er verwendet, um die Größe des Enumerators zu berechnen, ohne ihn durchlaufen zu müssen (siehe Enumerator#size).

Beispiele

str = "xyz"

enum = str.enum_for(:each_byte)
enum.each { |b| puts b }
# => 120
# => 121
# => 122

# protect an array from being modified by some_method
a = [1, 2, 3]
some_method(a.to_enum)

# String#split in block form is more memory-effective:
very_large_string.split("|") { |chunk| return chunk if chunk.include?('DATE') }
# This could be rewritten more idiomatically with to_enum:
very_large_string.to_enum(:split, "|").lazy.grep(/DATE/).first

Es ist üblich, to_enum aufzurufen, wenn Methoden für eine generische Enumerable definiert werden, falls kein Block übergeben wird.

Hier ist ein solches Beispiel mit Parameterübergabe und einem Größenblock

module Enumerable
  # a generic method to repeat the values of any enumerable
  def repeat(n)
    raise ArgumentError, "#{n} is negative!" if n < 0
    unless block_given?
      return to_enum(__method__, n) do # __method__ is :repeat here
        sz = size     # Call size and multiply by n...
        sz * n if sz  # but return nil if size itself is nil
      end
    end
    each do |*val|
      n.times { yield *val }
    end
  end
end

%i[hello world].repeat(2) { |w| puts w }
  # => Prints 'hello', 'hello', 'world', 'world'
enum = (1..14).repeat(3)
  # => returns an Enumerator when called without a block
enum.first(4) # => [1, 1, 1, 2]
enum.size # => 42

Gibt einen String zurück, der obj repräsentiert. Der Standard-to_s gibt den Klassennamen des Objekts und eine Kodierung der Objekt-ID aus. Als Sonderfall gibt das Top-Level-Objekt, das der anfängliche Ausführungskontext von Ruby-Programmen ist, „main“ zurück.

Konvertiert ein Objekt in YAML. Weitere Informationen zu den verfügbaren options finden Sie unter Psych.dump.