class Module

In der ersten Form wird ein Array der Namen aller Konstanten zurückgegeben, auf die vom Aufrufpunkt aus zugegriffen werden kann. Diese Liste enthält die Namen aller Module und Klassen, die im globalen Geltungsbereich definiert sind.

Module.constants.first(4)
   # => [:ARGF, :ARGV, :ArgumentError, :Array]

Module.constants.include?(:SEEK_SET)   # => false

class IO
  Module.constants.include?(:SEEK_SET) # => true
end

Die zweite Form ruft die Instanzmethode constants auf.

Gibt die Liste der im Aufrufpunkt verschachtelten Modules zurück.

module M1
  module M2
    $a = Module.nesting
  end
end
$a           #=> [M1::M2, M1]
$a[0].name   #=> "M1::M2"

Erstellt ein neues anonymes Modul. Wenn ein Block übergeben wird, wird ihm das Modulobjekt übergeben, und der Block wird im Kontext dieses Moduls ausgewertet, ähnlich wie bei module_eval.

fred = Module.new do
  def meth1
    "hello"
  end
  def meth2
    "bye"
  end
end
a = "my string"
a.extend(fred)   #=> "my string"
a.meth1          #=> "hello"
a.meth2          #=> "bye"

Weisen Sie das Modul einer Konstanten zu (Name beginnt mit Großbuchstabe), wenn Sie es wie ein reguläres Modul behandeln möchten.

Gibt ein Array aller im aktuellen Geltungsbereich verwendeten Module zurück. Die Reihenfolge der Module im Ergebnisarray ist nicht definiert.

module A
  refine Object do
  end
end

module B
  refine Object do
  end
end

using A
using B
p Module.used_modules

ergibt

[B, A]

Gibt ein Array aller im aktuellen Geltungsbereich verwendeten Module zurück. Die Reihenfolge der Module im Ergebnisarray ist nicht definiert.

module A
  refine Object do
  end
end

module B
  refine Object do
  end
end

using A
using B
p Module.used_refinements

ergibt

[#<refinement:Object@B>, #<refinement:Object@A>]

Gibt zurück, ob self eine Unterklasse von other ist, oder nil, wenn keine Beziehung zwischen beiden besteht

Float < Numeric # => true
Numeric < Float # => false
Float < Float   # => false
Float < Hash    # => nil

Gibt true zurück, wenn mod eine Unterklasse von other ist oder gleich other ist. Gibt nil zurück, wenn keine Beziehung zwischen beiden besteht. (Denken Sie an die Beziehung in Bezug auf die Klassendefinition: „class A < B“ impliziert „A < B“.)

Vergleicht self und other.

Gibt zurück

• -1, wenn self other inkludiert, wenn oder self eine Unterklasse von other ist.

• 0, wenn self und other gleich sind.

• 1, wenn other self inkludiert oder wenn other eine Unterklasse von self ist.

• nil, wenn keine der obigen Bedingungen zutrifft.

Beispiele

# Class Array includes module Enumerable.
         Array <=> Enumerable # => -1
    Enumerable <=> Enumerable # =>  0
    Enumerable <=> Array      # =>  1
# Class File is a subclass of class IO.
          File <=> IO         # => -1
          File <=> File       # =>  0
            IO <=> File       # =>  1
# Class File has no relationship to class String.
          File <=> String     # => nil

Gleichheit — Auf der Ebene von Object gibt == nur dann true zurück, wenn obj und other dasselbe Objekt sind. Typischerweise wird diese Methode in abgeleiteten Klassen überschrieben, um eine klassenspezifische Bedeutung 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) 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 auf denselben Hash-Schlüssel verweisen. Dies wird von Hash verwendet, um Elemente auf Gleichheit zu prüfen. 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? gleichbedeutend mit ==. Unterklassen setzen diese Tradition normalerweise fort, indem sie eql? mit ihrer überschriebenen ==-Methode verknüpfen, aber es gibt Ausnahmen. Numeric-Typen führen beispielsweise Typumwandlungen über == durch, aber nicht über eql?, daher

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

Fallgleichheit — Gibt true zurück, wenn obj eine Instanz von mod oder eine Instanz eines Nachfolgers von mod ist. Von begrenztem Nutzen für Module, kann aber in case-Anweisungen verwendet werden, um Objekte nach Klasse zu klassifizieren.

Gibt true zurück, wenn mod ein Vorfahre von other ist. Gibt false zurück, wenn mod dasselbe wie other ist oder wenn mod ein Nachfolger von other ist. Gibt nil zurück, wenn keine Beziehung zwischen beiden besteht. (Denken Sie an die Beziehung in Bezug auf die Klassendefinition: „class A < B“ impliziert „B > A“.)

Gibt true zurück, wenn mod ein Vorfahre von other ist oder die beiden Module gleich sind. Gibt nil zurück, wenn keine Beziehung zwischen beiden besteht. (Denken Sie an die Beziehung in Bezug auf die Klassendefinition: „class A < B“ impliziert „B > A“.)

Macht new_name zu einer neuen Kopie der Methode old_name. Dies kann verwendet werden, um den Zugriff auf überschriebene Methoden beizubehalten.

module Mod
  alias_method :orig_exit, :exit #=> :orig_exit
  def exit(code=0)
    puts "Exiting with code #{code}"
    orig_exit(code)
  end
end
include Mod
exit(99)

ergibt

Exiting with code 99

Gibt eine Liste der in mod inkludierten/vorangestellten Module zurück (einschließlich mod selbst).

module Mod
  include Math
  include Comparable
  prepend Enumerable
end

Mod.ancestors        #=> [Enumerable, Mod, Comparable, Math]
Math.ancestors       #=> [Math]
Enumerable.ancestors #=> [Enumerable]

Die erste Form ist äquivalent zu attr_reader. Die zweite Form ist äquivalent zu attr_accessor(name), aber veraltet. Die letzte Form ist äquivalent zu attr_reader(name), aber veraltet. Gibt ein Array definierter Methodennamen als Symbole zurück.

Definiert ein benanntes Attribut für dieses Modul, wobei der Name symbol.id2name ist, erstellt eine Instanzvariable (@name) und eine entsprechende Zugriffsmethode zum Lesen. Erstellt außerdem eine Methode namens name= zum Setzen des Attributs. String-Argumente werden in Symbole umgewandelt. Gibt ein Array definierter Methodennamen als Symbole zurück.

module Mod
  attr_accessor(:one, :two) #=> [:one, :one=, :two, :two=]
end
Mod.instance_methods.sort   #=> [:one, :one=, :two, :two=]

Erstellt Instanzvariablen und entsprechende Methoden, die den Wert jeder Instanzvariable zurückgeben. Äquivalent zum Aufruf von „attr:name“ für jeden Namen der Reihe nach. String-Argumente werden in Symbole umgewandelt. Gibt ein Array definierter Methodennamen als Symbole zurück.

Erstellt eine Zugriffsmethode, die das Setzen des Attributs symbol.id2name ermöglicht. String-Argumente werden in Symbole umgewandelt. Gibt ein Array definierter Methodennamen als Symbole zurück.

Registriert filename zur Ladung (mit Kernel::require) beim ersten Mal, wenn const (das eine String oder ein Symbol sein kann) im Namensraum von mod zugegriffen wird.

module A
end
A.autoload(:B, "b")
A::B.doit            # autoloads "b"

Wenn const in mod als autoload definiert ist, wird der zu ladende Dateiname durch filename ersetzt. Wenn const definiert ist, aber nicht als autoload, tut sich nichts.

Dateien, die gerade geladen werden, dürfen nicht für autoload registriert werden.

Gibt filename zurück, der geladen werden soll, wenn name im Namensraum von mod oder einem seiner Vorfahren als autoload registriert ist.

module A
end
A.autoload(:B, "b")
A.autoload?(:B)            #=> "b"

Wenn inherit false ist, prüft die Suche nur die autoloads im Empfänger.

class A
  autoload :CONST, "const.rb"
end

class B < A
end

B.autoload?(:CONST)          #=> "const.rb", found in A (ancestor)
B.autoload?(:CONST, false)   #=> nil, not found in B itself

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

class Fred
  @@foo = 99
end
Fred.class_variable_defined?(:@@foo)    #=> true
Fred.class_variable_defined?(:@@bar)    #=> false

Gibt den Wert der gegebenen Klassenvariable zurück (oder wirft eine NameError-Ausnahme). Der Teil @@ des Variablennamens sollte für reguläre Klassenvariablen enthalten sein. String-Argumente werden in Symbole umgewandelt.

class Fred
  @@foo = 99
end
Fred.class_variable_get(:@@foo)     #=> 99

Setzt die durch symbol benannte Klassenvariable auf das gegebene Objekt. Wenn der Klassenvariablenname als Zeichenkette übergeben wird, wird diese Zeichenkette in ein Symbol umgewandelt.

class Fred
  @@foo = 99
  def foo
    @@foo
  end
end
Fred.class_variable_set(:@@foo, 101)     #=> 101
Fred.new.foo                             #=> 101

Gibt ein Array der Namen von Klassenvariablen in mod zurück. Dies schließt die Namen von Klassenvariablen in allen inkludierten Modulen ein, es sei denn, der Parameter inherit ist auf false gesetzt.

class One
  @@var1 = 1
end
class Two < One
  @@var2 = 2
end
One.class_variables          #=> [:@@var1]
Two.class_variables          #=> [:@@var2, :@@var1]
Two.class_variables(false)   #=> [:@@var2]

Sagt, ob mod oder seine Vorfahren eine Konstante mit dem gegebenen Namen haben

Float.const_defined?(:EPSILON)      #=> true, found in Float itself
Float.const_defined?("String")      #=> true, found in Object (ancestor)
BasicObject.const_defined?(:Hash)   #=> false

Wenn mod ein Module ist, werden zusätzlich Object und seine Vorfahren überprüft.

Math.const_defined?(:String)   #=> true, found in Object

In jeder der überprüften Klassen oder Module, wenn die Konstante nicht vorhanden ist, aber eine autoload dafür existiert, wird true direkt zurückgegeben, ohne autoload auszulösen.

module Admin
  autoload :User, 'admin/user'
end
Admin.const_defined?(:User)   #=> true

Wenn die Konstante nicht gefunden wird, wird der Callback const_missing **nicht** aufgerufen und die Methode gibt false zurück.

Wenn inherit false ist, prüft die Suche nur die Konstanten im Empfänger.

IO.const_defined?(:SYNC)          #=> true, found in File::Constants (ancestor)
IO.const_defined?(:SYNC, false)   #=> false, not found in IO itself

In diesem Fall gilt die gleiche Logik für autoload.

Wenn das Argument kein gültiger Konstantenname ist, wird ein NameError mit der Meldung „wrong constant name name“ ausgelöst.

Hash.const_defined? 'foobar'   #=> NameError: wrong constant name foobar

Prüft auf eine Konstante mit dem gegebenen Namen in mod. Wenn inherit gesetzt ist, durchsucht die Suche auch die Vorfahren von mod (und Object, wenn mod ein Module ist).

Der Wert der Konstante wird zurückgegeben, wenn eine Definition gefunden wird, andernfalls wird eine NameError ausgelöst.

Math.const_get(:PI)   #=> 3.14159265358979

Diese Methode sucht rekursiv nach Konstantenamen, wenn ein benannter Klassennamen bereitgestellt wird. Zum Beispiel

module Foo; class Bar; end end
Object.const_get 'Foo::Bar'

Das Flag inherit wird bei jeder Suche berücksichtigt. Zum Beispiel

module Foo
  class Bar
    VAL = 10
  end

  class Baz < Bar; end
end

Object.const_get 'Foo::Baz::VAL'         # => 10
Object.const_get 'Foo::Baz::VAL', false  # => NameError

Wenn das Argument kein gültiger Konstantenname ist, wird ein NameError mit der Warnung „wrong constant name“ ausgelöst.

Object.const_get 'foobar' #=> NameError: wrong constant name foobar

Wird aufgerufen, wenn auf eine undefinierte Konstante in mod verwiesen wird. Ihr wird ein Symbol für die undefinierte Konstante übergeben, und sie gibt einen Wert zurück, der für diese Konstante verwendet wird. Betrachten Sie zum Beispiel

def Foo.const_missing(name)
  name # return the constant name as Symbol
end

Foo::UNDEFINED_CONST    #=> :UNDEFINED_CONST: symbol returned

Wie das obige Beispiel zeigt, ist const_missing nicht verpflichtet, die fehlende Konstante in mod zu erstellen, obwohl dies oft eine Nebenwirkung ist. Der Aufrufer erhält ihren Rückgabewert, wenn sie ausgelöst wird. Wenn die Konstante auch definiert ist, werden weitere Suchvorgänge const_missing nicht mehr auslösen und wie üblich den in der Konstante gespeicherten Wert zurückgeben. Andernfalls wird const_missing erneut aufgerufen.

Im folgenden Beispiel versucht const_missing beim Verweis auf eine undefinierte Konstante, eine Datei zu laden, deren Pfad die Kleinbuchstabenversion des Konstantennamens ist (wodurch die Klasse Fred in der Datei fred.rb angenommen wird). Wenn die Methode als Nebenwirkung des Ladens der Datei definiert ist, gibt sie den in der Konstante gespeicherten Wert zurück. Dies implementiert eine autoload-Funktionalität ähnlich wie Kernel#autoload und Module#autoload, unterscheidet sich jedoch in wichtigen Punkten.

def Object.const_missing(name)
  @looked_for ||= {}
  str_name = name.to_s
  raise "Constant not found: #{name}" if @looked_for[str_name]
  @looked_for[str_name] = 1
  file = str_name.downcase
  require file
  const_get(name, false)
end

Setzt die benannte Konstante auf das gegebene Objekt und gibt dieses Objekt zurück. Erstellt eine neue Konstante, wenn zuvor keine Konstante mit dem gegebenen Namen existierte.

Math.const_set("HIGH_SCHOOL_PI", 22.0/7.0)   #=> 3.14285714285714
Math::HIGH_SCHOOL_PI - Math::PI              #=> 0.00126448926734968

Wenn sym oder str kein gültiger Konstantenname ist, wird ein NameError mit der Warnung „wrong constant name“ ausgelöst.

Object.const_set('foobar', 42) #=> NameError: wrong constant name foobar

Gibt den Ruby-Quellcode-Dateinamen und die Zeilennummer zurück, die die Definition der angegebenen Konstante enthalten. Wenn die benannte Konstante nicht gefunden wird, wird nil zurückgegeben. Wenn die Konstante gefunden wird, aber ihre Quellcode-Position nicht extrahiert werden kann (die Konstante ist in C-Code definiert), wird ein leeres Array zurückgegeben.

inherit gibt an, ob in mod.ancestors gesucht werden soll (standardmäßig true).

# test.rb:
class A         # line 1
  C1 = 1
  C2 = 2
end

module M        # line 6
  C3 = 3
end

class B < A     # line 10
  include M
  C4 = 4
end

class A # continuation of A definition
  C2 = 8 # constant redefinition; warned yet allowed
end

p B.const_source_location('C4')           # => ["test.rb", 12]
p B.const_source_location('C3')           # => ["test.rb", 7]
p B.const_source_location('C1')           # => ["test.rb", 2]

p B.const_source_location('C3', false)    # => nil  -- don't lookup in ancestors

p A.const_source_location('C2')           # => ["test.rb", 16] -- actual (last) definition place

p Object.const_source_location('B')       # => ["test.rb", 10] -- top-level constant could be looked through Object
p Object.const_source_location('A')       # => ["test.rb", 1] -- class reopening is NOT considered new definition

p B.const_source_location('A')            # => ["test.rb", 1]  -- because Object is in ancestors
p M.const_source_location('A')            # => ["test.rb", 1]  -- Object is not ancestor, but additionally checked for modules

p Object.const_source_location('A::C1')   # => ["test.rb", 2]  -- nesting is supported
p Object.const_source_location('String')  # => []  -- constant is defined in C code

Gibt ein Array der Namen der in mod zugänglichen Konstanten zurück. Dies schließt die Namen von Konstanten in allen inkludierten Modulen ein (Beispiel am Anfang des Abschnitts), es sei denn, der Parameter inherit ist auf false gesetzt.

Die Implementierung macht keine Garantien bezüglich der Reihenfolge, in der die Konstanten übergeben werden.

IO.constants.include?(:SYNC)        #=> true
IO.constants(false).include?(:SYNC) #=> false

Siehe auch Module#const_defined?.

Definiert eine Instanzmethode im Empfänger. Der Parameter method kann ein Proc, eine Method oder ein UnboundMethod-Objekt sein. Wenn ein Block angegeben ist, wird er als Methodenrumpf verwendet. Wenn ein Block oder der Parameter method Parameter hat, werden diese als Methodenparameter verwendet. Dieser Block wird mit instance_eval ausgewertet.

class A
  def fred
    puts "In Fred"
  end
  def create_method(name, &block)
    self.class.define_method(name, &block)
  end
  define_method(:wilma) { puts "Charge it!" }
  define_method(:flint) {|name| puts "I'm #{name}!"}
end
class B < A
  define_method(:barney, instance_method(:fred))
end
a = B.new
a.barney
a.wilma
a.flint('Dino')
a.create_method(:betty) { p self }
a.betty

ergibt

In Fred
Charge it!
I'm Dino!
#<B:0x401b39e8>

Macht eine Liste vorhandener Konstanten veraltet. Der Versuch, auf sie zuzugreifen, erzeugt eine Warnung.

module HTTP
  NotFound = Exception.new
  NOT_FOUND = NotFound # previous version of the library used this name

  deprecate_constant :NOT_FOUND
end

HTTP::NOT_FOUND
# warning: constant HTTP::NOT_FOUND is deprecated

Verhindert weitere Änderungen an mod.

Diese Methode gibt self zurück.

Ruft Module.append_features für jeden Parameter in umgekehrter Reihenfolge auf.

Gibt true zurück, wenn module in mod oder einem der Vorfahren von mod inkludiert oder vorangestellt ist.

module A
end
class B
  include A
end
class C < B
end
B.include?(A)   #=> true
C.include?(A)   #=> true
A.include?(A)   #=> false

Gibt die Liste der Module zurück, die in mod oder einem der Vorfahren von mod inkludiert oder vorangestellt sind.

module Sub
end

module Mixin
  prepend Sub
end

module Outer
  include Mixin
end

Mixin.included_modules   #=> [Sub]
Outer.included_modules   #=> [Sub, Mixin]

Gibt eine UnboundMethod zurück, die die gegebene Instanzmethode in mod darstellt.

class Interpreter
  def do_a() print "there, "; end
  def do_d() print "Hello ";  end
  def do_e() print "!\n";     end
  def do_v() print "Dave";    end
  Dispatcher = {
    "a" => instance_method(:do_a),
    "d" => instance_method(:do_d),
    "e" => instance_method(:do_e),
    "v" => instance_method(:do_v)
  }
  def interpret(string)
    string.each_char {|b| Dispatcher[b].bind(self).call }
  end
end

interpreter = Interpreter.new
interpreter.interpret('dave')

ergibt

Hello there, Dave!

Gibt ein Array zurück, das die Namen der öffentlichen und geschützten Instanzmethoden im Empfänger enthält. Für ein Modul sind dies die öffentlichen und geschützten Methoden; für eine Klasse sind es die Instanzmethoden (nicht Singleton-Methoden). Wenn der optionale Parameter false ist, werden die Methoden von Vorfahren nicht berücksichtigt.

module A
  def method1()  end
end
class B
  include A
  def method2()  end
end
class C < B
  def method3()  end
end

A.instance_methods(false)                   #=> [:method1]
B.instance_methods(false)                   #=> [:method2]
B.instance_methods(true).include?(:method1) #=> true
C.instance_methods(false)                   #=> [:method3]
C.instance_methods.include?(:method2)       #=> true

Beachten Sie, dass Sichtbarkeitsänderungen von Methoden in der aktuellen Klasse sowie Aliase als Methoden der aktuellen Klasse von dieser Methode betrachtet werden.

class C < B
  alias method4 method2
  protected :method2
end
C.instance_methods(false).sort               #=> [:method2, :method3, :method4]

Gibt true zurück, wenn die benannte Methode von mod definiert ist. Wenn inherit gesetzt ist, durchsucht die Suche auch die Vorfahren von mod. Öffentliche und geschützte Methoden werden abgeglichen. String-Argumente werden in Symbole umgewandelt.

module A
  def method1()  end
  def protected_method1()  end
  protected :protected_method1
end
class B
  def method2()  end
  def private_method2()  end
  private :private_method2
end
class C < B
  include A
  def method3()  end
end

A.method_defined? :method1              #=> true
C.method_defined? "method1"             #=> true
C.method_defined? "method2"             #=> true
C.method_defined? "method2", true       #=> true
C.method_defined? "method2", false      #=> false
C.method_defined? "method3"             #=> true
C.method_defined? "protected_method1"   #=> true
C.method_defined? "method4"             #=> false
C.method_defined? "private_method2"     #=> false

wertet die Zeichenkette oder den Block im Kontext von mod aus, außer dass bei Übergabe eines Blocks die Suche nach Konstanten/Klassenvariablen nicht beeinflusst wird. Dies kann zum Hinzufügen von Methoden zu einer Klasse verwendet werden. module_eval gibt das Ergebnis der Auswertung seines Arguments zurück. Die optionalen Parameter filename und lineno legen den Text für Fehlermeldungen fest.

class Thing
end
a = %q{def hello() "Hello there!" end}
Thing.module_eval(a)
puts Thing.new.hello()
Thing.module_eval("invalid code", "dummy", 123)

ergibt

Hello there!
dummy:123:in `module_eval': undefined local variable
    or method `code' for Thing:Class

wertet den gegebenen Block im Kontext der Klasse/des Moduls aus. Die im Block definierte Methode gehört dem Empfänger. An das Attribut übergebene Argumente werden an den Block übergeben. Dies kann verwendet werden, wenn der Block auf Instanzvariablen zugreifen muss.

class Thing
end
Thing.class_exec{
  def hello() "Hello there!" end
}
puts Thing.new.hello()

ergibt

Hello there!

Gibt den Namen des Moduls mod zurück. Für anonyme Module wird nil zurückgegeben.

Ruft Module.prepend_features für jeden Parameter in umgekehrter Reihenfolge auf.

Macht vorhandene Klassenmethoden privat. Wird oft verwendet, um den Standardkonstruktor new zu verbergen.

String-Argumente werden in Symbole umgewandelt. Es wird auch ein Array von Symbolen und/oder Zeichenketten akzeptiert.

class SimpleSingleton  # Not thread safe
  private_class_method :new
  def SimpleSingleton.create(*args, &block)
    @me = new(*args, &block) if ! @me
    @me
  end
end

Macht eine Liste vorhandener Konstanten privat.

Gibt eine Liste der privaten Instanzmethoden zurück, die in mod definiert sind. Wenn der optionale Parameter false ist, werden die Methoden von Vorfahren nicht berücksichtigt.

module Mod
  def method1()  end
  private :method1
  def method2()  end
end
Mod.instance_methods           #=> [:method2]
Mod.private_instance_methods   #=> [:method1]

Gibt true zurück, wenn die benannte private Methode von mod definiert ist. Wenn inherit gesetzt ist, durchsucht die Suche auch die Vorfahren von mod. String-Argumente werden in Symbole umgewandelt.

module A
  def method1()  end
end
class B
  private
  def method2()  end
end
class C < B
  include A
  def method3()  end
end

A.method_defined? :method1                   #=> true
C.private_method_defined? "method1"          #=> false
C.private_method_defined? "method2"          #=> true
C.private_method_defined? "method2", true    #=> true
C.private_method_defined? "method2", false   #=> false
C.method_defined? "method2"                  #=> false

Gibt eine Liste der geschützten Instanzmethoden zurück, die in mod definiert sind. Wenn der optionale Parameter false ist, werden die Methoden von Vorfahren nicht berücksichtigt.

Gibt true zurück, wenn die benannte geschützte Methode von mod definiert ist. Wenn inherit gesetzt ist, durchsucht die Suche auch die Vorfahren von mod. String-Argumente werden in Symbole umgewandelt.

module A
  def method1()  end
end
class B
  protected
  def method2()  end
end
class C < B
  include A
  def method3()  end
end

A.method_defined? :method1                    #=> true
C.protected_method_defined? "method1"         #=> false
C.protected_method_defined? "method2"         #=> true
C.protected_method_defined? "method2", true   #=> true
C.protected_method_defined? "method2", false  #=> false
C.method_defined? "method2"                   #=> true

Macht eine Liste vorhandener Klassenmethoden öffentlich.

String-Argumente werden in Symbole umgewandelt. Es wird auch ein Array von Symbolen und/oder Zeichenketten akzeptiert.

Macht eine Liste vorhandener Konstanten öffentlich.

Ähnlich wie instance_method, durchsucht nur öffentliche Methoden.

Gibt eine Liste der öffentlichen Instanzmethoden zurück, die in mod definiert sind. Wenn der optionale Parameter false ist, werden die Methoden von Vorfahren nicht berücksichtigt.

Gibt true zurück, wenn die benannte öffentliche Methode von mod definiert ist. Wenn inherit gesetzt ist, durchsucht die Suche auch die Vorfahren von mod. String-Argumente werden in Symbole umgewandelt.

module A
  def method1()  end
end
class B
  protected
  def method2()  end
end
class C < B
  include A
  def method3()  end
end

A.method_defined? :method1                 #=> true
C.public_method_defined? "method1"         #=> true
C.public_method_defined? "method1", true   #=> true
C.public_method_defined? "method1", false  #=> true
C.public_method_defined? "method2"         #=> false
C.method_defined? "method2"                #=> true

Gibt ein Array von Refinement zurück, die innerhalb des Empfängers definiert sind.

module A
  refine Integer do
  end

  refine String do
  end
end

p A.refinements

ergibt

[#<refinement:Integer@A>, #<refinement:String@A>]

Entfernt die benannte Klassenvariable aus dem Empfänger und gibt den Wert dieser Variablen zurück.

class Example
  @@var = 99
  puts remove_class_variable(:@@var)
  p(defined? @@var)
end

ergibt

99
nil

Entfernt die durch symbol identifizierte Methode aus der aktuellen Klasse. Ein Beispiel finden Sie unter Module#undef_method. String-Argumente werden in Symbole umgewandelt.

Setzt den temporären Namen des Moduls. Dieser Name spiegelt sich in der Introspektion des Moduls und den zugehörigen Werten wie Instanzen, Konstanten und Methoden wider.

Der Name sollte nil oder eine nicht leere Zeichenkette sein, die kein gültiger Pfad zu einer Konstanten ist (um Verwechslungen zwischen permanenten und temporären Namen zu vermeiden).

Die Methode kann nützlich sein, um dynamisch generierte Klassen und Module zu unterscheiden, ohne ihnen Konstanten zuzuweisen.

Wenn dem Modul durch Zuweisung zu einer Konstanten ein permanenter Name zugewiesen wird, wird der temporäre Name verworfen. Ein temporärer Name kann Modulen nicht zugewiesen werden, die einen permanenten Namen haben.

Wenn der angegebene Name nil ist, wird das Modul wieder anonym.

Beispiel

m = Module.new # => #<Module:0x0000000102c68f38>
m.name #=> nil

m.set_temporary_name("fake_name") # => fake_name
m.name #=> "fake_name"

m.set_temporary_name(nil) # => #<Module:0x0000000102c68f38>
m.name #=> nil

c = Class.new
c.set_temporary_name("MyClass(with description)") # => MyClass(with description)

c.new # => #<MyClass(with description):0x0....>

c::M = m
c::M.name #=> "MyClass(with description)::M"

# Assigning to a constant replaces the name with a permanent one
C = c

C.name #=> "C"
C::M.name #=> "C::M"
c.new # => #<C:0x0....>

Gibt true zurück, wenn mod eine Singleton-Klasse ist, oder false, wenn es sich um eine gewöhnliche Klasse oder ein Modul handelt.

class C
end
C.singleton_class?                  #=> false
C.singleton_class.singleton_class?  #=> true

Gibt eine Zeichenkette zurück, die dieses Modul oder diese Klasse darstellt. Für grundlegende Klassen und Module ist dies der Name. Für Singletons zeigen wir Informationen über das Ding an, an das sie angehängt sind.

Verhindert, dass die aktuelle Klasse auf Aufrufe der benannten Methode reagiert. Im Gegensatz zu remove_method, das die Methode aus der jeweiligen Klasse löscht; Ruby durchsucht weiterhin Oberklassen und gemischte Module nach einem möglichen Empfänger. String-Argumente werden in Symbole umgewandelt.

class Parent
  def hello
    puts "In parent"
  end
end
class Child < Parent
  def hello
    puts "In child"
  end
end

c = Child.new
c.hello

class Child
  remove_method :hello  # remove from child, still in parent
end
c.hello

class Child
  undef_method :hello   # prevent any calls to 'hello'
end
c.hello

ergibt

In child
In parent
prog.rb:23: undefined method 'hello' for #<Child:0x401b3bb4> (NoMethodError)

Gibt eine Liste der undefinierten Instanzmethoden zurück, die in mod definiert sind. Die undefinierten Methoden von Vorfahren sind nicht enthalten.

Wenn dieses Modul in ein anderes inkludiert wird, ruft Ruby append_features in diesem Modul auf und übergibt ihm das empfangende Modul in mod. Die Standardimplementierung von Ruby besteht darin, die Konstanten, Methoden und Modulvariablen dieses Moduls zu mod hinzuzufügen, wenn dieses Modul noch nicht zu mod oder einem seiner Vorfahren hinzugefügt wurde. Siehe auch Module#include.

Wird als Callback aufgerufen, wann immer eine Konstante auf dem Empfänger zugewiesen wird.

module Chatty
  def self.const_added(const_name)
    super
    puts "Added #{const_name.inspect}"
  end
  FOO = 1
end

ergibt

Added :FOO

Wenn wir eine Klasse mit dem Schlüsselwort class definieren, wird const_added vor inherited ausgeführt.

module M
  def self.const_added(const_name)
    super
    p :const_added
  end

  parent = Class.new do
    def self.inherited(subclass)
      super
      p :inherited
    end
  end

  class Child < parent
  end
end

ergibt

:const_added
:inherited

Erweitert das angegebene Objekt, indem die Konstanten und Methoden dieses Moduls hinzugefügt werden (die als Singleton-Methoden hinzugefügt werden). Dies ist die Callback-Methode, die von Object#extend verwendet wird.

module Picky
  def Picky.extend_object(o)
    if String === o
      puts "Can't add Picky to a String"
    else
      puts "Picky added to #{o.class}"
      super
    end
  end
end
(s = Array.new).extend Picky  # Call Object.extend
(s = "quick brown fox").extend Picky

ergibt

Picky added to Array
Can't add Picky to a String

Das Äquivalent zu included, aber für erweiterte Module.

module A
  def self.extended(mod)
    puts "#{self} extended in #{mod}"
  end
end
module Enumerable
  extend A
end
 # => prints "A extended in Enumerable"

Callback, der aufgerufen wird, wenn der Empfänger in ein anderes Modul oder eine andere Klasse inkludiert wird. Dies sollte bevorzugt vor Module.append_features verwendet werden, wenn Ihr Code eine Aktion ausführen möchte, wenn ein Modul in ein anderes inkludiert wird.

module A
  def A.included(mod)
    puts "#{self} included in #{mod}"
  end
end
module Enumerable
  include A
end
 # => prints "A included in Enumerable"

Wird als Callback aufgerufen, wann immer eine Instanzmethode zum Empfänger hinzugefügt wird.

module Chatty
  def self.method_added(method_name)
    puts "Adding #{method_name.inspect}"
  end
  def self.some_class_method() end
  def some_instance_method() end
end

ergibt

Adding :some_instance_method

Wird als Callback aufgerufen, wann immer eine Instanzmethode vom Empfänger entfernt wird.

module Chatty
  def self.method_removed(method_name)
    puts "Removing #{method_name.inspect}"
  end
  def self.some_class_method() end
  def some_instance_method() end
  class << self
    remove_method :some_class_method
  end
  remove_method :some_instance_method
end

ergibt

Removing :some_instance_method

Wird als Callback aufgerufen, wann immer eine Instanzmethode vom Empfänger undefiniert wird.

module Chatty
  def self.method_undefined(method_name)
    puts "Undefining #{method_name.inspect}"
  end
  def self.some_class_method() end
  def some_instance_method() end
  class << self
    undef_method :some_class_method
  end
  undef_method :some_instance_method
end

ergibt

Undefining :some_instance_method

Erzeugt Modulfunktionen für die benannten Methoden. Diese Funktionen können mit dem Modul als Empfänger aufgerufen werden und werden auch als Instanzmethoden für Klassen verfügbar, die das Modul mischen. Modulfunktionen sind Kopien des Originals und können daher unabhängig voneinander geändert werden. Die Instanzmethodenversionen werden privat gemacht. Wenn mit keinen Argumenten verwendet, werden nachfolgend definierte Methoden zu Modulfunktionen. String-Argumente werden in Symbole umgewandelt. Wenn ein einzelnes Argument übergeben wird, wird es zurückgegeben. Wenn kein Argument übergeben wird, wird nil zurückgegeben. Wenn mehrere Argumente übergeben werden, werden die Argumente als Array zurückgegeben.

module Mod
  def one
    "This is one"
  end
  module_function :one
end
class Cls
  include Mod
  def call_one
    one
  end
end
Mod.one     #=> "This is one"
c = Cls.new
c.call_one  #=> "This is one"
module Mod
  def one
    "This is the new one"
  end
end
Mod.one     #=> "This is one"
c.call_one  #=> "This is the new one"

Wenn dieses Modul in ein anderes vorangestellt wird, ruft Ruby prepend_features in diesem Modul auf und übergibt ihm das empfangende Modul in mod. Die Standardimplementierung von Ruby besteht darin, die Konstanten, Methoden und Modulvariablen dieses Moduls zu mod zu überlagern, wenn dieses Modul noch nicht zu mod oder einem seiner Vorfahren hinzugefügt wurde. Siehe auch Module#prepend.

Das Äquivalent zu included, aber für vorangestellte Module.

module A
  def self.prepended(mod)
    puts "#{self} prepended to #{mod}"
  end
end
module Enumerable
  prepend A
end
 # => prints "A prepended to Enumerable"

Ohne Argumente wird die Standard-Sichtbarkeit für nachfolgend definierte Methoden auf privat gesetzt. Mit Argumenten werden die benannten Methoden auf private Sichtbarkeit gesetzt. String-Argumente werden in Symbole umgewandelt. Es wird auch ein Array von Symbolen und/oder Zeichenketten akzeptiert. Wenn ein einzelnes Argument übergeben wird, wird es zurückgegeben. Wenn kein Argument übergeben wird, wird nil zurückgegeben. Wenn mehrere Argumente übergeben werden, werden die Argumente als Array zurückgegeben.

module Mod
  def a()  end
  def b()  end
  private
  def c()  end
  private :a
end
Mod.private_instance_methods   #=> [:a, :c]

Beachten Sie, dass zur Anzeige einer privaten Methode auf RDoc :doc: verwendet wird.

Setzt die Sichtbarkeit eines Abschnitts oder einer Liste von Methodennamen als geschützt. Akzeptiert keine Argumente, eine Splat von Methodennamen (Symbole oder Zeichenketten) oder ein Array von Methodennamen. Gibt die empfangenen Argumente zurück.

Wichtiger Unterschied zu geschützten Methoden in anderen Sprachen

Geschützte Methoden in Ruby unterscheiden sich von denen in anderen Sprachen wie Java, wo Methoden als geschützt markiert werden, um Unterklassen Zugriff zu gewähren. In Ruby haben Unterklassen **bereits Zugriff auf alle Methoden, die in der übergeordneten Klasse definiert sind**, auch auf private.

Das Markieren einer Methode als geschützt erlaubt **anderen Objekten derselben Klasse**, sie aufzurufen.

Ein Anwendungsfall sind Vergleichsmethoden wie ==, wenn wir eine Methode zum Vergleich zwischen Objekten derselben Klasse verfügbar machen möchten, ohne die Methode für Objekte anderer Klassen öffentlich zu machen.

Leistungsüberlegungen

Geschützte Methoden sind langsamer als andere, da sie keinen Inline-Cache verwenden können.

Beispiel

class Account
  # Mark balance as protected, so that we can compare between accounts
  # without making it public.
  attr_reader :balance
  protected :balance

  def initialize(balance)
    @balance = balance
  end

  def >(other)
    # The invocation to `other.balance` is allowed because `other` is a
    # different object of the same class (Account).
    balance > other.balance
  end
end

account1 = Account.new(100)
account2 = Account.new(50)

account1 > account2  # => true (works)
account1.balance     # => NoMethodError (fails because balance is not public)

Zur Anzeige einer privaten Methode auf RDoc verwenden Sie stattdessen :doc:.

Ohne Argumente wird die Standard-Sichtbarkeit für nachfolgend definierte Methoden auf öffentlich gesetzt. Mit Argumenten werden die benannten Methoden auf öffentliche Sichtbarkeit gesetzt. String-Argumente werden in Symbole umgewandelt. Es wird auch ein Array von Symbolen und/oder Zeichenketten akzeptiert. Wenn ein einzelnes Argument übergeben wird, wird es zurückgegeben. Wenn kein Argument übergeben wird, wird nil zurückgegeben. Wenn mehrere Argumente übergeben werden, werden die Argumente als Array zurückgegeben.

Verfeinert mod im Empfänger.

Gibt ein Modul zurück, in dem verfeinerte Methoden definiert werden.

Entfernt die Definition der gegebenen Konstante und gibt den vorherigen Wert dieser Konstante zurück. Wenn sich diese Konstante auf ein Modul bezog, ändert dies nicht den Namen dieses Moduls und kann zu Verwirrung führen.

Markiert für die gegebenen Methodennamen die Methode als durchlaufende Schlüsselwörter über ein normales Argument-Splat. Dies sollte nur auf Methoden angewendet werden, die einen Argument-Splat (*args) akzeptieren, aber keine expliziten Schlüsselwörter oder einen Schlüsselwort-Splat. Es markiert die Methode so, dass, wenn die Methode mit Schlüsselwortargumenten aufgerufen wird, das letzte Hash-Argument mit einem speziellen Flag markiert wird, so dass, wenn es das letzte Element eines normalen Argument-Splats an einen anderen Methodenaufruf ist und dieser Methodenaufruf keine expliziten Schlüsselwörter oder einen Schlüsselwort-Splat enthält, das letzte Element als Schlüsselwörter interpretiert wird. Mit anderen Worten, Schlüsselwörter werden über die Methode an andere Methoden weitergegeben.

Dies sollte nur für Methoden verwendet werden, die Schlüsselwörter an eine andere Methode delegieren, und nur zur Abwärtskompatibilität mit Ruby-Versionen vor 3.0. Weitere Informationen darüber, warum ruby2_keywords existiert und wann und wie es verwendet werden sollte, finden Sie unter www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0.

Diese Methode wird wahrscheinlich irgendwann entfernt, da sie nur zur Abwärtskompatibilität existiert. Da sie in Ruby-Versionen vor 2.7 nicht existiert, prüfen Sie, ob das Modul auf diese Methode reagiert, bevor Sie sie aufrufen.

module Mod
  def foo(meth, *args, &block)
    send(:"do_#{meth}", *args, &block)
  end
  ruby2_keywords(:foo) if respond_to?(:ruby2_keywords, true)
end

Beachten Sie jedoch, dass sich das Verhalten der Methode foo mit dem obigen Ansatz ändert, wenn die Methode ruby2_keywords entfernt wird, sodass die Methode keine Schlüsselwörter mehr durchlässt.

Importiert Klassenverfeinerungen aus module in die aktuelle Klassen- oder Moduldefinition.