Ruby Language
Selbstbeobachtung

Zeigen Sie die Methoden eines Objekts an

Objekt prüfen

Sie finden die öffentlichen Methoden, auf die ein Objekt reagieren kann, entweder mit den methods oder mit den methods public_methods , die ein Array von Symbolen zurückgeben:

class Foo
  def bar; 42; end
end
f = Foo.new
def f.yay; 17; end
p f.methods.sort
#=> [:!, :!=, :!~, :<=>, :==, :===, :=~, :__id__, :__send__, :bar, :class, :clone,
#=>  :define_singleton_method, :display, :dup, :enum_for, :eql?, :equal?, :extend,
#=>  :freeze, :frozen?, :hash, :inspect, :instance_eval, :instance_exec,
#=>  :instance_of?, :instance_variable_defined?, :instance_variable_get,
#=>  :instance_variable_set, :instance_variables, :is_a?, :itself, :kind_of?, 
#=>  :method, :methods, :nil?, :object_id, :private_methods, :protected_methods,
#=>  :public_method, :public_methods, :public_send, :remove_instance_variable,
#=>  :respond_to?, :send, :singleton_class, :singleton_method, :singleton_methods,
#=>  :taint, :tainted?, :tap, :to_enum, :to_s, :trust, :untaint, :untrust,
#=>  :untrusted?, :yay]

Für eine gezieltere Liste können Sie Methoden entfernen, die allen Objekten gemeinsam sind, z

p (f.methods - Object.methods).sort
#=> [:bar,:yay]

Alternativ können Sie false an methods oder public_methods :

p f.methods(false) # public and protected singleton methods of `f`
#=> [:yay]

p f.public_methods(false)
#=> [:yay, :bar]

Sie können die privaten und geschützten Methoden eines Objekts mit private_methods und protected_methods :

p f.private_methods.sort
#=> [:Array, :Complex, :DelegateClass, :Float, :Hash, :Integer, :Rational, :String,
#=>  :__callee__, :__dir__, :__method__, :`, :abort, :at_exit, :autoload, :autoload?,
#=>  :binding, :block_given?, :caller, :caller_locations, :catch,
#=>  :default_src_encoding, :eval, :exec, :exit, :exit!, :fail, :fork, :format, :gem,
#=>  :gem_original_require, :gets, :global_variables, :initialize, :initialize_clone,
#=>  :initialize_copy, :initialize_dup, :irb_binding, :iterator?, :lambda, :load,
#=>  :local_variables, :loop, :method_missing, :open, :p, :print, :printf, :proc,
#=>  :putc, :puts, :raise, :rand, :readline, :readlines, :require, :require_relative,
#=>  :respond_to_missing?, :select, :set_trace_func, :singleton_method_added,
#=>  :singleton_method_removed, :singleton_method_undefined, :sleep, :spawn,
#=>  :sprintf, :srand, :syscall, :system, :test, :throw, :trace_var, :trap,
#=>  :untrace_var, :warn]

p f.protected_methods
#=> []

Wie bei methods und public_methods können Sie false an private_methods und protected_methods , um geerbte Methoden private_methods .

Prüfung einer Klasse oder eines Moduls

Neben methods , public_methods , protected_methods und private_methods , Klassen und Module aussetzen instance_methods , public_instance_methods , protected_instance_methods und private_instance_methods die Methoden für die Objekte ausgesetzt , um zu bestimmen , die von der Klasse oder dem Modul erben. Wie oben können Sie den Methoden false zuweisen, um geerbte Methoden auszuschließen:

p Foo.instance_methods.sort
#=> [:!, :!=, :!~, :<=>, :==, :===, :=~, :__id__, :__send__, :bar, :class,
#=>  :clone, :define_singleton_method, :display, :dup, :enum_for, :eql?,
#=>  :equal?, :extend, :freeze, :frozen?, :hash, :inspect, :instance_eval,
#=>  :instance_exec, :instance_of?, :instance_variable_defined?,
#=>  :instance_variable_get, :instance_variable_set, :instance_variables,
#=>  :is_a?, :itself, :kind_of?, :method, :methods, :nil?, :object_id,
#=>  :private_methods, :protected_methods, :public_method, :public_methods,
#=>  :public_send, :remove_instance_variable, :respond_to?, :send,
#=>  :singleton_class, :singleton_method, :singleton_methods, :taint,
#=>  :tainted?, :tap, :to_enum, :to_s, :trust, :untaint, :untrust, :untrusted?]

p Foo.instance_methods(false)
#=> [:bar]

Wenn Sie die Namen der meisten dieser Elemente in der Zukunft vergessen, können Sie alle Methoden mithilfe von methods :

p f.methods.grep(/methods/)
#=> [:private_methods, :methods, :protected_methods, :public_methods,
#=>  :singleton_methods]

p Foo.methods.grep(/methods/)
#=> [:public_instance_methods, :instance_methods, :private_instance_methods,
#=>  :protected_instance_methods, :private_methods, :methods,
#=>  :protected_methods, :public_methods, :singleton_methods]

Zeigen Sie die Instanzvariablen eines Objekts an

Es ist möglich , ein Objekt über seine Instanzvariablen abfragen instance_variables , instance_variable_defined? und instance_variable_get und ändern Sie sie mithilfe von instance_variable_set und remove_instance_variable :

class Foo
  attr_reader :bar
  def initialize
    @bar = 42
  end
end
f = Foo.new
f.instance_variables                #=> [:@bar]
f.instance_variable_defined?(:@baz) #=> false
f.instance_variable_defined?(:@bar) #=> true
f.instance_variable_get(:@bar)      #=> 42
f.instance_variable_set(:@bar, 17)   #=> 17
f.bar                               #=> 17
f.remove_instance_variable(:@bar)   #=> 17
f.bar                               #=> nil
f.instance_variables                #=> []

Die Namen der Instanzvariablen enthalten das @ -Symbol. Sie erhalten eine Fehlermeldung, wenn Sie sie weglassen:

f.instance_variable_defined?(:jim)
#=> NameError: `jim' is not allowed as an instance variable name

Globale und lokale Variablen anzeigen

Der Kernel stellt Methoden zum global_variables der Liste global_variables und local_variables :

cats  = 42
$demo = "in progress"
p global_variables.sort
#=> [:$!, :$", :$$, :$&, :$', :$*, :$+, :$,, :$-0, :$-F, :$-I, :$-K, :$-W, :$-a,
#=>  :$-d, :$-i, :$-l, :$-p, :$-v, :$-w, :$., :$/, :$0, :$1, :$2, :$3, :$4, :$5,
#=>  :$6, :$7, :$8, :$9, :$:, :$;, :$<, :$=, :$>, :$?, :$@, :$DEBUG, :$FILENAME,
#=>  :$KCODE, :$LOADED_FEATURES, :$LOAD_PATH, :$PROGRAM_NAME, :$SAFE, :$VERBOSE,
#=>  :$\, :$_, :$`, :$binding, :$demo, :$stderr, :$stdin, :$stdout, :$~]

p local_variables
#=> [:cats]

Im Gegensatz zu Instanzvariablen gibt es keine speziellen Methoden, um globale oder lokale Variablen abzurufen, festzulegen oder zu entfernen. Die Suche nach einer solchen Funktionalität ist normalerweise ein Zeichen dafür, dass Ihr Code umgeschrieben werden muss, um einen Hash zum Speichern der Werte zu verwenden. Wenn Sie jedoch globale oder lokale Variablen nach Namen ändern müssen, können Sie eval mit einer Zeichenfolge verwenden:

var = "$demo"
eval(var)           #=> "in progress"
eval("#{var} = 17")
p $demo             #=> 17

Standardmäßig wertet eval Ihre Variablen im aktuellen Bereich aus. Um lokale Variablen in einem anderen Bereich auszuwerten, müssen Sie die Bindung erfassen, in der die lokalen Variablen vorhanden sind.

def local_variable_get(name, bound=nil)
  foo = :inside
  eval(name,bound)
end

def test_1
  foo = :outside
  p local_variable_get("foo")
end

def test_2
  foo = :outside
  p local_variable_get("foo",binding)
end
  
test_1 #=> :inside
test_2 #=> :outside

Im obigen test_1 hat test_1 keine Bindung an local_variable_get , und daher wurde das eval im Kontext dieser Methode ausgeführt, wobei eine lokale Variable mit dem Namen foo auf local_variable_get gesetzt wurde :inside

Klassenvariablen anzeigen

Klassen und Module verfügen über die gleichen Methoden für die Introspektion von Instanzvariablen wie jedes andere Objekt. Klassen und Module verfügen auch über ähnliche Methoden zum Abfragen der Klassenvariablen ( @@these_things ):

p Module.methods.grep(/class_variable/)
#=> [:class_variables, :class_variable_get, :remove_class_variable,
#=>  :class_variable_defined?, :class_variable_set]

class Foo
  @@instances = 0
  def initialize
    @@instances += 1
  end
end

class Bar < Foo; end

5.times{ Foo.new }
3.times{ Bar.new }
p Foo.class_variables                   #=> [:@@instances]
p Bar.class_variables                   #=> [:@@instances]
p Foo.class_variable_get(:@@instances)  #=> 8
p Bar.class_variable_get(:@@instances)  #=> 8

Ähnlich wie bei Instanzvariablen muss der Name von Klassenvariablen mit @@ beginnen, oder Sie erhalten einen Fehler:

p Bar.class_variable_defined?( :instances )
#=> NameError: `instances' is not allowed as a class variable name