Returns true if two objects does not match, using =~ method.

Case Equality—For class Object, effectively the same as calling #==, but typically overridden by descendents to provide meaningful semantics in case statements.

Pattern Match—Overridden by descendents (notably Regexp and String) to provide meaningful pattern-match semantics.

Document-method: object_id

Returns an integer identifier for obj. The same number will be returned on all calls to id for a given object, and no two active objects will share an id. Object#object_id is a different concept from the :name notation, which returns the symbol id of name. Replaces the deprecated Object#id.

Returns the class of obj, now preferred over Object#type, as an object‘s type in Ruby is only loosely tied to that object‘s class. This method must always be called with an explicit receiver, as class is also a reserved word in Ruby.

   1.class      #=> Fixnum
   self.class   #=> Object

Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference. Copies the frozen and tainted state of obj. See also the discussion under Object#dup.

   class Klass
      attr_accessor :str
   end
   s1 = Klass.new      #=> #<Klass:0x401b3a38>
   s1.str = "Hello"    #=> "Hello"
   s2 = s1.clone       #=> #<Klass:0x401b3998 @str="Hello">
   s2.str[1,4] = "i"   #=> "i"
   s1.inspect          #=> "#<Klass:0x401b3a38 @str=\"Hi\">"
   s2.inspect          #=> "#<Klass:0x401b3998 @str=\"Hi\">"

This method may have class-specific behavior. If so, that behavior will be documented under the #initialize_copy method of the class.

Prints obj on the given port (default $>). Equivalent to:

   def display(port=$>)
     port.write self
   end

For example:

   1.display
   "cat".display
   [ 4, 5, 6 ].display
   puts

produces:

   1cat456

Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference. dup copies the tainted state of obj. See also the discussion under Object#clone. In general, clone and dup may have different semantics in descendent classes. While clone is used to duplicate an object, including its internal state, dup typically uses the class of the descendent object to create the new instance.

This method may have class-specific behavior. If so, that behavior will be documented under the #initialize_copy method of the class.

Returns Enumerable::Enumerator.new(self, method, *args).

e.g.:

   str = "xyz"

   enum = str.enum_for(:each_byte)
   a = enum.map {|b| '%02x' % b } #=> ["78", "79", "7a"]

   # protects an array from being modified
   a = [1, 2, 3]
   some_method(a.to_enum)

Equality—At the Object level, == returns true only if obj and other are the same object. Typically, this method is overridden in descendent classes to provide class-specific meaning.

Unlike ==, the equal? method should never be overridden by subclasses: it is used to determine object identity (that is, a.equal?(b) iff a is the same object as b).

The eql? method returns true if obj and anObject have the same value. Used by Hash to test members for equality. For objects of class Object, eql? is synonymous with ==. Subclasses normally continue this tradition, but there are exceptions. Numeric types, for example, perform type conversion across ==, but not across eql?, so:

   1 == 1.0     #=> true
   1.eql? 1.0   #=> false

Adds to obj the instance methods from each module given as a parameter.

   module Mod
     def hello
       "Hello from Mod.\n"
     end
   end

   class Klass
     def hello
       "Hello from Klass.\n"
     end
   end

   k = Klass.new
   k.hello         #=> "Hello from Klass.\n"
   k.extend(Mod)   #=> #<Klass:0x401b3bc8>
   k.hello         #=> "Hello from Mod.\n"

Prevents further modifications to obj. A TypeError will be raised if modification is attempted. There is no way to unfreeze a frozen object. See also Object#frozen?.

   a = [ "a", "b", "c" ]
   a.freeze
   a << "z"

produces:

   prog.rb:3:in `<<': can't modify frozen array (TypeError)
    from prog.rb:3

Returns the freeze status of obj.

   a = [ "a", "b", "c" ]
   a.freeze    #=> ["a", "b", "c"]
   a.frozen?   #=> true

Generates a Fixnum hash value for this object. This function must have the property that a.eql?(b) implies a.hash == b.hash. The hash value is used by class Hash. Any hash value that exceeds the capacity of a Fixnum will be truncated before being used.

Returns a string containing a human-readable representation of obj. If not overridden, uses the to_s method to generate the string.

   [ 1, 2, 3..4, 'five' ].inspect   #=> "[1, 2, 3..4, \"five\"]"
   Time.new.inspect                 #=> "2008-03-08 19:43:39 +0900"

Returns true if obj is an instance of the given class. See also Object#kind_of?.

Returns true if the given instance variable is defined in obj.

   class Fred
     def initialize(p1, p2)
       @a, @b = p1, p2
     end
   end
   fred = Fred.new('cat', 99)
   fred.instance_variable_defined?(:@a)    #=> true
   fred.instance_variable_defined?("@b")   #=> true
   fred.instance_variable_defined?("@c")   #=> false

Returns the value of the given instance variable, or nil if the instance variable is not set. The @ part of the variable name should be included for regular instance variables. Throws a NameError exception if the supplied symbol is not valid as an instance variable name.

   class Fred
     def initialize(p1, p2)
       @a, @b = p1, p2
     end
   end
   fred = Fred.new('cat', 99)
   fred.instance_variable_get(:@a)    #=> "cat"
   fred.instance_variable_get("@b")   #=> 99

Sets the instance variable names by symbol to object, thereby frustrating the efforts of the class‘s author to attempt to provide proper encapsulation. The variable did not have to exist prior to this call.

   class Fred
     def initialize(p1, p2)
       @a, @b = p1, p2
     end
   end
   fred = Fred.new('cat', 99)
   fred.instance_variable_set(:@a, 'dog')   #=> "dog"
   fred.instance_variable_set(:@c, 'cat')   #=> "cat"
   fred.inspect                             #=> "#<Fred:0x401b3da8 @a=\"dog\", @b=99, @c=\"cat\">"

Returns an array of instance variable names for the receiver. Note that simply defining an accessor does not create the corresponding instance variable.

   class Fred
     attr_accessor :a1
     def initialize
       @iv = 3
     end
   end
   Fred.new.instance_variables   #=> [:@iv]

Returns true if class is the class of obj, or if class is one of the superclasses of obj or modules included in obj.

   module M;    end
   class A
     include M
   end
   class B < A; end
   class C < B; end
   b = B.new
   b.instance_of? A   #=> false
   b.instance_of? B   #=> true
   b.instance_of? C   #=> false
   b.instance_of? M   #=> false
   b.kind_of? A       #=> true
   b.kind_of? B       #=> true
   b.kind_of? C       #=> false
   b.kind_of? M       #=> true

Returns true if class is the class of obj, or if class is one of the superclasses of obj or modules included in obj.

   module M;    end
   class A
     include M
   end
   class B < A; end
   class C < B; end
   b = B.new
   b.instance_of? A   #=> false
   b.instance_of? B   #=> true
   b.instance_of? C   #=> false
   b.instance_of? M   #=> false
   b.kind_of? A       #=> true
   b.kind_of? B       #=> true
   b.kind_of? C       #=> false
   b.kind_of? M       #=> true

Looks up the named method as a receiver in obj, returning a Method object (or raising NameError). The Method object acts as a closure in obj‘s object instance, so instance variables and the value of self remain available.

   class Demo
     def initialize(n)
       @iv = n
     end
     def hello()
       "Hello, @iv = #{@iv}"
     end
   end

   k = Demo.new(99)
   m = k.method(:hello)
   m.call   #=> "Hello, @iv = 99"

   l = Demo.new('Fred')
   m = l.method("hello")
   m.call   #=> "Hello, @iv = Fred"

Returns a list of the names of methods publicly accessible in obj. This will include all the methods accessible in obj‘s ancestors.

   class Klass
     def kMethod()
     end
   end
   k = Klass.new
   k.methods[0..9]    #=> ["kMethod", "freeze", "nil?", "is_a?",
                      #    "class", "instance_variable_set",
                      #    "methods", "extend", "__send__", "instance_eval"]
   k.methods.length   #=> 42

call_seq:

  nil.nil?               => true
  <anything_else>.nil?   => false

Only the object nil responds true to nil?.

Returns an integer identifier for obj. The same number will be returned on all calls to id for a given object, and no two active objects will share an id. Object#object_id is a different concept from the :name notation, which returns the symbol id of name. Replaces the deprecated Object#id.

Returns the list of private methods accessible to obj. If the all parameter is set to false, only those methods in the receiver will be listed.

Returns the list of protected methods accessible to obj. If the all parameter is set to false, only those methods in the receiver will be listed.

Returns the list of public methods accessible to obj. If the all parameter is set to false, only those methods in the receiver will be listed.

Invokes the method identified by symbol, passing it any arguments specified. Unlike send, public_send calls public methods only.

   1.public_send(:puts, "hello")  # causes NoMethodError

Removes the named instance variable from obj, returning that variable‘s value.

   class Dummy
     attr_reader :var
     def initialize
       @var = 99
     end
     def remove
       remove_instance_variable(:@var)
     end
   end
   d = Dummy.new
   d.var      #=> 99
   d.remove   #=> 99
   d.var      #=> nil

Returns true> if obj responds to the given method. Private methods are included in the search only if the optional second parameter evaluates to true.

Invokes the method identified by symbol, passing it any arguments specified. You can use send if the name send clashes with an existing method in obj.

   class Klass
     def hello(*args)
       "Hello " + args.join(' ')
     end
   end
   k = Klass.new
   k.send :hello, "gentle", "readers"   #=> "Hello gentle readers"

Returns an array of the names of singleton methods for obj. If the optional all parameter is true, the list will include methods in modules included in obj.

   module Other
     def three() end
   end

   class Single
     def Single.four() end
   end

   a = Single.new

   def a.one()
   end

   class << a
     include Other
     def two()
     end
   end

   Single.singleton_methods    #=> [:four]
   a.singleton_methods(false)  #=> [:two, :one]
   a.singleton_methods         #=> [:two, :one, :three]

Marks obj as tainted—if the $SAFE level is set appropriately, many method calls which might alter the running programs environment will refuse to accept tainted strings.

Returns true if the object is tainted.

Yields x to the block, and then returns x. The primary purpose of this method is to "tap into" a method chain, in order to perform operations on intermediate results within the chain.

    (1..10)                .tap {|x| puts "original: #{x.inspect}"}
      .to_a                .tap {|x| puts "array: #{x.inspect}"}
      .select {|x| x%2==0} .tap {|x| puts "evens: #{x.inspect}"}
      .map { |x| x*x }     .tap {|x| puts "squares: #{x.inspect}"}

Returns Enumerable::Enumerator.new(self, method, *args).

e.g.:

   str = "xyz"

   enum = str.enum_for(:each_byte)
   a = enum.map {|b| '%02x' % b } #=> ["78", "79", "7a"]

   # protects an array from being modified
   a = [1, 2, 3]
   some_method(a.to_enum)

Returns a string representing obj. The default to_s prints the object‘s class and an encoding of the object id. As a special case, the top-level object that is the initial execution context of Ruby programs returns ``main.’‘

Removes the taint from obj.