Ruby Language
Selbstbeobachtung
Suche…
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
