Wie stellen Sie die aktuell verfügbaren Objekte im aktuellen Bereich in Ruby?

Question

Ich bin neu in Ruby und ich spiele um mit dem IRB.

Ich fand, dass ich Methoden einer Objektliste können die „.methods“ -Methode verwendet wird, und dass self.methods Art mir geben, was ich will (ähnlich wie Pythons dir ( builtins )?) , aber wie kann ich die Methoden einer Bibliothek / Modul finden ich habe über enthalten geladen und benötigen?

irb(main):036:0* self.methods
=> ["irb_pop_binding", "inspect", "taguri", "irb_chws", "clone", "irb_pushws", "public_methods", "taguri=", "irb_pwws",
"public", "display", "irb_require", "irb_exit", "instance_variable_defined?", "irb_cb", "equal?", "freeze", "irb_context
", "irb_pop_workspace", "irb_cwb", "irb_jobs", "irb_bindings", "methods", "irb_current_working_workspace", "respond_to?"
, "irb_popb", "irb_cws", "fg", "pushws", "conf", "dup", "cwws", "instance_variables", "source", "cb", "kill", "help", "_
_id__", "method", "eql?", "irb_pwb", "id", "bindings", "send", "singleton_methods", "popb", "irb_kill", "chws", "taint",
 "irb_push_binding", "instance_variable_get", "frozen?", "irb_source", "pwws", "private", "instance_of?", "__send__", "i
rb_workspaces", "to_a", "irb_quit", "to_yaml_style", "irb_popws", "irb_change_workspace", "jobs", "type", "install_alias
_method", "irb_push_workspace", "require_gem", "object_id", "instance_eval", "protected_methods", "irb_print_working_wor
kspace", "irb_load", "require", "==", "cws", "===", "irb_pushb", "instance_variable_set", "irb_current_working_binding",
 "extend", "kind_of?", "context", "gem", "to_yaml_properties", "quit", "popws", "irb", "to_s", "to_yaml", "irb_fg", "cla
ss", "hash", "private_methods", "=~", "tainted?", "include", "irb_cwws", "irb_change_binding", "irb_help", "untaint", "n
il?", "pushb", "exit", "irb_print_working_binding", "is_a?", "workspaces"]
irb(main):037:0>

Ich bin auf Python verwendet, wo ich die dir () Funktion verwenden, um die gleiche Sache zu tun:

>>> dir()
['__builtins__', '__doc__', '__name__', '__package__']
>>>

Answer 1

ObjectSpace.each_object könnte sein, was Sie suchen.

Um eine Liste der enthaltenen Module erhalten Sie Module.included_modules .

Sie können auch überprüfen, ob ein Objekt auf einer Fall-zu-Fall-Basis mit object.respond_to? .

Answer 2

Ich bin nicht ganz sicher, was Sie von den ‚aktuellen Objekten‘ bedeuten. Sie können über Objectlaufen, wie bereits erwähnt wurde. Aber hier sind ein paar andere Methoden.

local_variables
instance_variables
global_variables

class_variables
constants

Es gibt eine Gotcha. Sie müssen an den richtigen Bereichen aufgerufen werden. So richtig in IRB, oder in einer Objektinstanz oder Klassenbereich (so überall, im Grunde) können Sie die ersten 3 nennen.

local_variables #=> ["_"]
foo = "bar"
local_variables #=> ["_", "foo"]
# Note: the _ variable in IRB contains the last value evaluated
_ #=> "bar"

instance_variables  #=> []
@inst_var = 42
instance_variables  #=> ["@inst_var"]

global_variables    #=> ["$-d", "$\"", "$$", "$<", "$_", ...]
$"                  #=> ["e2mmap.rb", "irb/init.rb", "irb/workspace.rb", ...]

Aber umm, was, wenn Sie Ihr Programm, um sie tatsächlich zu bewerten, ohne dass man sie manyally geben? Der Trick ist, eval.

eval "@inst_var" #=> 42
global_variables.each do |v|
  puts eval(v)
end

Die letzten 2 der 5 am Anfang erwähnt muss auf Modulebene ausgewertet werden (eine Klasse ist ein Nachkomme eines Moduls, so dass Arbeiten).

Object.class_variables #=> []
Object.constants #=> ["IO", "Duration", "UNIXserver", "Binding", ...]

class MyClass
  A_CONST = 'pshh'
  class InnerClass
  end
  def initialize
    @@meh = "class_var"
  end
end

MyClass.constants           #=> ["A_CONST", "InnerClass"]
MyClass.class_variables     #=> []
mc = MyClass.new
MyClass.class_variables     #=> ["@@meh"]
MyClass.class_eval "@@meh"  #=> "class_var"

Hier sind ein paar mehr Tricks in verschiedenen Richtungen

erkunden

"".class            #=> String
"".class.ancestors  #=> [String, Enumerable, Comparable, ...]
String.ancestors    #=> [String, Enumerable, Comparable, ...]

def trace
  return caller
end
trace #=> ["(irb):67:in `irb_binding'", "/System/Library/Frameworks/Ruby...", ...]

Answer 3

Die dir() Methode ist nicht klar definiert ...

  

Hinweis: Da dir() geliefert   in erster Linie als Annehmlichkeit für die Verwendung bei   eine interaktive Eingabeaufforderung, es versucht,   eine interessante Reihe von Namen liefern   mehr, als es versucht, eine liefern   rigoros oder einheitlich definierten Satz   von Namen, und seinem detaillierten Verhalten   ändern kann über Versionen.

... aber wir können eine enge Annäherung in Ruby erstellen. Lassen Sie uns ein Verfahren machen, die eine sortierte Liste aller Methoden in unseren Katalog aufgenommen Umfang durch mitgelieferte Module zurück. Wir können eine Liste der Module erhalten, die mithilfe des included_modules Verfahren aufgenommen wurden.

Wie dir() wollen wir die „default“ Methoden (wie print) ignorieren, und wir wollen auch auf der „interessante“ Reihe von Namen konzentrieren. So werden wir Methoden in Kernel ignorieren, und wir werden nur Methoden zurück, die direkt in den Modulen definiert wurden, geerbte Methoden zu ignorieren. Wir können das später erreichen, indem false in die methods() Methode übergeben. Dass sie alle zusammen bekommen wir ...

def included_methods(object=self)
  object = object.class if object.class != Class
  modules = (object.included_modules-[Kernel])
  modules.collect{ |mod| mod.methods(false)}.flatten.sort
end

Sie können es eine Klasse übergeben, ein Objekt oder nichts (es standardmäßig auf den aktuellen Bereich). Lassen Sie uns versuchen Sie es aus ...

irb(main):006:0> included_methods
=> []
irb(main):007:0> include Math
=> Object
irb(main):008:0> included_methods
=> ["acos", "acosh", "asin", "asinh", "atan", "atan2", "atanh", "cos", "cosh", "erf", "erfc", "exp", "frexp", "hypot", "ldexp", "log", "log10", "sin", "sinh", "sqrt", "tan", "tanh"]

---

dir() enthält auch lokal definierten Variablen, und das ist leicht. Rufen Sie einfach ...

local_variables

... leider können wir nicht nur den local_variables Anruf in dem included_methods, weil es uns die Variablen geben würde, die die included_methods Methode lokal sind, und das wäre nicht sehr nützlich sein. Also, wenn Sie lokale Variablen mit dem included_methods enthalten wollen, rufen Sie einfach an ...

 (included_methods + local_variables).sort

Answer 4

Ich schrieb ein Juwel für das:

$ gem install method_info
$ rvm use 1.8.7 # (1.8.6 works but can be very slow for an object with a lot of methods)
$ irb
> require 'method_info'
> 5.method_info
::: Fixnum :::
%, &, *, **, +, -, -@, /, <, <<, <=, <=>, ==, >, >=, >>, [], ^, abs,
div, divmod, even?, fdiv, id2name, modulo, odd?, power!, quo, rdiv,
rpower, size, to_f, to_s, to_sym, zero?, |, ~
::: Integer :::
ceil, chr, denominator, downto, floor, gcd, gcdlcm, integer?, lcm,
next, numerator, ord, pred, round, succ, taguri, taguri=, times, to_i,
to_int, to_r, to_yaml, truncate, upto
::: Precision :::
prec, prec_f, prec_i
::: Numeric :::
+@, coerce, eql?, nonzero?, pretty_print, pretty_print_cycle,
remainder, singleton_method_added, step
::: Comparable :::
between?
::: Object :::
clone, to_yaml_properties, to_yaml_style, what?
::: MethodInfo::ObjectMethod :::
method_info
::: Kernel :::
===, =~, __clone__, __id__, __send__, class, display, dup, enum_for,
equal?, extend, freeze, frozen?, hash, id, inspect, instance_eval,
instance_exec, instance_of?, instance_variable_defined?,
instance_variable_get, instance_variable_set, instance_variables,
is_a?, kind_of?, method, methods, nil?, object_id, pretty_inspect,
private_methods, protected_methods, public_methods, respond_to?, ri,
send, singleton_methods, taint, tainted?, tap, to_a, to_enum, type,
untaint
 => nil

Ich arbeite an einer Verbesserung von Optionen und Einstellungen Standardwerte vorbei, aber jetzt würde ich vorschlagen, dass Sie die folgenden Ihre .irbrc-Datei hinzu:

require 'method_info'
MethodInfo::OptionHandler.default_options = {
 :ancestors_to_exclude => [Object],
 :enable_colors => true
}

Dies ermöglicht Farben und versteckt die Methoden, die jedes Objekt hat, da Sie in denen in der Regel nicht interessiert sind.

Answer 5

Was ist mit:

Object.constants.select{|x| eval(x.to_s).class == Class}

Das Listen verfügbaren Klassen für mich. Ich bin kein Experte Rubin und ich war ohne zu wissen, an einem Rubin Konsole fallen gelassen werden, welche Klassen zur Hand waren. Das Motto war ein Anfang.

Answer 6

Um alle Objektinstanzen in Ruby Sie Object verwenden Zugriff

http: //www.ruby-doc .org / core-1.8.7 / classes / ObjectSpace.html # M000928

Dies wird jedoch langsam betrachtet (auch für Rubin), und in einigen Dolmetscher kann nicht aktiviert werden (zB JRuby können Object deaktivieren, da es viel schneller in die JVM für gc verlassen, ohne dass dieses Zeug in JRuby verfolgen).

Answer 7

Sie können die .methods Nachrichten an die Bibliothek / Modul übergeben, noch bevor es geladen wird, um zu sehen, alle verfügbaren Methoden. Doing self.methods kehrt nur alle Methoden, die das Objekt-Objekt enthält. Sie können dies sehen von self.class tun. Also lassen Sie uns sagen, Sie alle Methoden in der Datei-Modul angezeigt werden sollen. Sie einfach nicht File.methods und Sie erhalten eine Liste aller Methoden erhalten, die in der Datei-Modul vorhanden sind. Dies ist vielleicht nicht das, was Sie wollen, aber es sollte etwas hilfreich sein.