Ruby Language
Introspezione

Visualizza i metodi di un oggetto

Ispezionare un oggetto

È possibile trovare i metodi pubblici a cui un oggetto può rispondere utilizzando i methods oi metodi public_methods , che restituiscono una matrice di simboli:

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]

Per un elenco più mirato, è possibile rimuovere i metodi comuni a tutti gli oggetti, ad es

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

In alternativa, puoi passare false a methods o public_methods :

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

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

Puoi trovare i metodi privati ​​e protetti di un oggetto usando private_methods e 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
#=> []

Come per i methods e public_methods , puoi passare false a private_methods e protected_methods per tagliare via i metodi ereditati.

Ispezionando una classe o un modulo

Oltre ai methods , public_methods , protected_methods e private_methods , classi e moduli espongono instance_methods , public_instance_methods , protected_instance_methods e private_instance_methods per determinare i metodi esposti per gli oggetti che ereditano dalla classe o dal modulo. Come sopra, puoi passare false a questi metodi per escludere metodi ereditati:

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]

Infine, se dimentichi i nomi di molti di questi in futuro, puoi trovare tutti questi metodi usando i 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]

Visualizza le variabili di istanza di un oggetto

È possibile interrogare un oggetto sulle sue variabili di instance_variables usando instance_variables , instance_variable_defined? e instance_variable_get e modificarli usando instance_variable_set e 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                #=> []

I nomi delle variabili di istanza includono il simbolo @ . Riceverai un errore se lo ometti:

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

Visualizza variabili globali e locali

Il Kernel espone i metodi per ottenere l'elenco di global_variables e 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]

A differenza delle variabili di istanza, non esistono metodi specifici per ottenere, impostare o rimuovere variabili globali o locali. La ricerca di tale funzionalità è di solito un segno che il tuo codice dovrebbe essere riscritto per utilizzare un hash per memorizzare i valori. Tuttavia, se è necessario modificare le variabili globali o locali per nome, è possibile utilizzare eval con una stringa:

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

Di default, eval valuterà le tue variabili nell'ambito corrente. Per valutare le variabili locali in un ambito diverso, è necessario acquisire il legame in cui esistono le variabili locali.

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

In quanto sopra, test_1 non ha passato un'associazione a local_variable_get , e quindi l' eval stato eseguito nel contesto di quel metodo, dove una variabile locale di nome foo stata impostata su :inside .

Visualizza le variabili di classe

Classi e moduli hanno gli stessi metodi per l'analisi delle variabili di istanza come qualsiasi altro oggetto. Anche la classe e i moduli hanno metodi simili per interrogare le variabili di classe ( @@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

Simile alle variabili di istanza, il nome delle variabili di classe deve iniziare con @@ oppure si otterrà un errore:

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