Ruby methods() method

I want to understand how Ruby method methods() work.

I tried to Google with "ruby methods" but it's not what i need.

Also i've seen ruby-doc.org, but i didn't find this method.

Can you expain me how it works in details or give me a link?

Update

I experimented with methods() method and got such results:

'lab rat' code

class First
  def first_instance_mymethod
  end
  def self.first_class_mymethod
  end
end
class Second < First
  def second_instance_mymethod
  end
  def self.second_class_mymethod
  end
end

Work with Classes

#returns available methods list for class and ancestors
puts Second.methods.grep(/mymethod/)
  # => second_class_mymethod
  # => first_class_mymethod

#returns Class methods list for current class only 
puts Second.methods(false)
  # => second_class_mymethod

Work with Objects

obj = Second.new
def obj.obj_singleton_mymethod
end

#returns available methods list for object and ancestors
puts obj.methods.grep(/mymethod/)
  # => second_instance_mymethod
  # => first_instance_mymethod

#returns current object class methods
puts obj.methods(false)
  # => obj_singl开发者_开发问答eton_mymethod

The accepted answer misses a slight point. A fuller answer was given in the comment by keymone - .methods returns an array of symbols being names of all the methods defined on the given instance. For example:

irb(main):012:0> object = ""
=> ""
irb(main):013:0> object.instance_eval("def foo;:bar;end")
=> nil
irb(main):014:0> object.methods.include?(:foo)
=> true
irb(main):016:0> "".methods.include?(:foo)
=> false

I'm not entirely sure why it's not in the ruby 1.9 docs (it seems to still be in the code), but you can see the documentation in the 1.8.7 docs: http://www.ruby-doc.org/core-1.8.7/classes/Object.html#M000032

Basically, in ruby 1.9 it just returns a list of the symbols (names) for all the methods in a given class and its ancestors. (ruby 1.8 it returned a list of strings)

I'm on Ruby 2.2.5 and I am unfortunately not getting this to work when passed false any longer. I do remember back on older versions of Ruby, passing false to this method used to return only the class-level methods.

However, as of Ruby 2.2.5, here's what I'm getting

class Thingy < ApplicationRecord
  def hello

  end
end

class Apple < Thingy
  def self.goodbye

  end


  def booty

  end
end

results:

2.2.5 :001 > a = Thingy.new
 => #<Thingy id: nil, created_at: nil, updated_at: nil> 
2.2.5 :002 > a.methods(false)
 => [] 
2.2.5 :003 > b = Apple.new
 => #<Apple id: nil, created_at: nil, updated_at: nil> 
2.2.5 :004 > b.methods(false)
 => [] 
2.2.5 :005 > Apple.methods(false)
 => [:attribute_type_decorations, :_validators, :defined_enums, :goodbye] 
2.2.5 :006 > Thingy.methods(false)
 => [:attribute_type_decorations, :_validators, :defined_enums] 
2.2.5 :007 > 

the only time passing false returns anything interesting to me is to examine class-level methods only (those that start with self.) Otherwise it seems to not be helpful anymore.