Class: Object

Inherits:
BasicObject
Includes:
Kernel
Defined in:
object.c

Overview

Object is the parent class of all classes in Ruby. Its methods are therefore available to all objects unless explicitly overridden.

Object mixes in the Kernel module, making the built-in kernel functions globally accessible. Although the instance methods of Object are defined by the Kernel module, we have chosen to document them here for clarity.

In the descriptions of Object’s methods, the parameter symbol refers to a symbol, which is either a quoted string or a Symbol (such as :name).

Instance Method Summary collapse

Methods included from Kernel

#Array, #Float, #Integer, #String, #abort, #at_exit, #autoload, #autoload?, #binding, #block_given?, #callcc, #caller, #catch, #chomp, #chomp!, #chop, #chop!, #eval, #exit, #fail, #format, #global_variables, #gsub, #gsub!, #iterator?, #lambda, #load, #local_variables, #loop, #method_missing, #proc, #raise, #rand, #require, #scan, #set_trace_func, #split, #sprintf, #srand, #sub, #sub!, #test, #throw, #trace_var, #trap, #untrace_var, #warn

Constructor Details

#initialize ⇒ Object (private)

Not documented



630
631
632
633
634
 
# File 'object.c', line 630

static VALUE
rb_obj_dummy()
{
    return Qnil;
}

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class Kernel

Instance Method Details

#==(other) ⇒ Boolean #equal?(other) ⇒ Boolean #eql?(other) ⇒ Boolean

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

<i>obj</i> and <i>anObject</i> 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

Overloads:

  • #==(other) ⇒ Boolean

    Returns:

    • (Boolean)
  • #equal?(other) ⇒ Boolean

    Returns:

    • (Boolean)
  • #eql?(other) ⇒ Boolean

    Returns:

    • (Boolean) 


93
94
95
 
# File 'object.c', line 93

static VALUE
rb_obj_equal(obj1, obj2)
VALUE obj1, obj2;

#===(other) ⇒ Boolean

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

Returns:

  • (Boolean) 


45
46
47
 
# File 'object.c', line 45

VALUE
rb_equal(obj1, obj2)
VALUE obj1, obj2;

#=~(other) ⇒ false

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

Returns:

  • (false) 


1071
1072
1073
 
# File 'object.c', line 1071

static VALUE
rb_obj_pattern_match(obj1, obj2)
VALUE obj1, obj2;

#hash ⇒ Fixnum

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:



1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
 
# File 'gc.c', line 1992

VALUE
rb_obj_id(VALUE obj)
{
    /*
     *                32-bit VALUE space
     *          MSB ------------------------ LSB
     *  false   00000000000000000000000000000000
     *  true    00000000000000000000000000000010
     *  nil     00000000000000000000000000000100
     *  undef   00000000000000000000000000000110
     *  symbol  ssssssssssssssssssssssss00001110
     *  object  oooooooooooooooooooooooooooooo00        = 0 (mod sizeof(RVALUE))
     *  fixnum  fffffffffffffffffffffffffffffff1
     *
     *                    object_id space
     *                                       LSB
     *  false   00000000000000000000000000000000
     *  true    00000000000000000000000000000010
     *  nil     00000000000000000000000000000100
     *  undef   00000000000000000000000000000110
     *  symbol   000SSSSSSSSSSSSSSSSSSSSSSSSSSS0        S...S % A = 4 (S...S = s...s * A + 4)
     *  object   oooooooooooooooooooooooooooooo0        o...o % A = 0
     *  fixnum  fffffffffffffffffffffffffffffff1        bignum if required
     *
     *  where A = sizeof(RVALUE)/4
     *
     *  sizeof(RVALUE) is
     *  20 if 32-bit, double is 4-byte aligned
     *  24 if 32-bit, double is 8-byte aligned
     *  40 if 64-bit
     */
    if (TYPE(obj) == T_SYMBOL) {
        return (SYM2ID(obj) * sizeof(RVALUE) + (4 << 2)) | FIXNUM_FLAG;
    }
    if (SPECIAL_CONST_P(obj)) {
        return LONG2NUM((long)obj);
    }
    return (VALUE)((long)obj|FIXNUM_FLAG);
}

#send(symbol[, args...]) ⇒ Object #__send__(symbol[, args...]) ⇒ Object

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"

Overloads:



6098
6099
6100
 
# File 'eval.c', line 6098

static VALUE
rb_f_send(argc, argv, recv)
int argc;

#class ⇒ Class

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

Returns:



156
157
158
 
# File 'object.c', line 156

VALUE
rb_obj_class(obj)
VALUE obj;

#clone ⇒ 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.

Returns:



215
216
217
 
# File 'object.c', line 215

VALUE
rb_obj_clone(obj)
VALUE obj;

#dup ⇒ Object

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:



251
252
253
 
# File 'object.c', line 251

VALUE
rb_obj_dup(obj)
VALUE obj;

#==(other) ⇒ Boolean #equal?(other) ⇒ Boolean #eql?(other) ⇒ Boolean

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

<i>obj</i> and <i>anObject</i> 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

Overloads:

  • #==(other) ⇒ Boolean

    Returns:

    • (Boolean)
  • #equal?(other) ⇒ Boolean

    Returns:

    • (Boolean)
  • #eql?(other) ⇒ Boolean

    Returns:

    • (Boolean) 


93
94
95
 
# File 'object.c', line 93

static VALUE
rb_obj_equal(obj1, obj2)
VALUE obj1, obj2;

#==(other) ⇒ Boolean #equal?(other) ⇒ Boolean #eql?(other) ⇒ Boolean

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

<i>obj</i> and <i>anObject</i> 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

Overloads:

  • #==(other) ⇒ Boolean

    Returns:

    • (Boolean)
  • #equal?(other) ⇒ Boolean

    Returns:

    • (Boolean)
  • #eql?(other) ⇒ Boolean

    Returns:

    • (Boolean) 


93
94
95
 
# File 'object.c', line 93

static VALUE
rb_obj_equal(obj1, obj2)
VALUE obj1, obj2;

#extend ⇒ Object

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"

Returns:



7665
7666
7667
 
# File 'eval.c', line 7665

static VALUE
rb_obj_extend(argc, argv, obj)
int argc;

#freeze ⇒ Object

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:



724
725
726
 
# File 'object.c', line 724

VALUE
rb_obj_freeze(obj)
VALUE obj;

#frozen? ⇒ Boolean

Returns the freeze status of obj.

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

Returns:

  • (Boolean) 


748
749
750
 
# File 'object.c', line 748

static VALUE
rb_obj_frozen_p(obj)
VALUE obj;

#hash ⇒ Fixnum

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:



1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
 
# File 'gc.c', line 1992

VALUE
rb_obj_id(VALUE obj)
{
    /*
     *                32-bit VALUE space
     *          MSB ------------------------ LSB
     *  false   00000000000000000000000000000000
     *  true    00000000000000000000000000000010
     *  nil     00000000000000000000000000000100
     *  undef   00000000000000000000000000000110
     *  symbol  ssssssssssssssssssssssss00001110
     *  object  oooooooooooooooooooooooooooooo00        = 0 (mod sizeof(RVALUE))
     *  fixnum  fffffffffffffffffffffffffffffff1
     *
     *                    object_id space
     *                                       LSB
     *  false   00000000000000000000000000000000
     *  true    00000000000000000000000000000010
     *  nil     00000000000000000000000000000100
     *  undef   00000000000000000000000000000110
     *  symbol   000SSSSSSSSSSSSSSSSSSSSSSSSSSS0        S...S % A = 4 (S...S = s...s * A + 4)
     *  object   oooooooooooooooooooooooooooooo0        o...o % A = 0
     *  fixnum  fffffffffffffffffffffffffffffff1        bignum if required
     *
     *  where A = sizeof(RVALUE)/4
     *
     *  sizeof(RVALUE) is
     *  20 if 32-bit, double is 4-byte aligned
     *  24 if 32-bit, double is 8-byte aligned
     *  40 if 64-bit
     */
    if (TYPE(obj) == T_SYMBOL) {
        return (SYM2ID(obj) * sizeof(RVALUE) + (4 << 2)) | FIXNUM_FLAG;
    }
    if (SPECIAL_CONST_P(obj)) {
        return LONG2NUM((long)obj);
    }
    return (VALUE)((long)obj|FIXNUM_FLAG);
}

#id ⇒ Fixnum

Soon-to-be deprecated version of Object#object_id.

Returns:



108
109
110
 
# File 'object.c', line 108

VALUE
rb_obj_id_obsolete(obj)
VALUE obj;

#initialize_copy ⇒ Object

:nodoc:



267
268
269
 
# File 'object.c', line 267

VALUE
rb_obj_init_copy(obj, orig)
VALUE obj, orig;

#inspect ⇒ String

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                 #=> "Wed Apr 09 08:54:39 CDT 2003"

Returns:



391
392
393
 
# File 'object.c', line 391

static VALUE
rb_obj_inspect(obj)
VALUE obj;

#instance_eval(string[, filename [, lineno]]) ⇒ Object #instance_eval {|| ... } ⇒ Object

Evaluates a string containing Ruby source code, or the given block, within the context of the receiver (obj). In order to set the context, the variable self is set to obj while the code is executing, giving the code access to obj’s instance variables. In the version of instance_eval that takes a String, the optional second and third parameters supply a filename and starting line number that are used when reporting compilation errors.

class Klass
  def initialize
    @secret = 99
  end
end
k = Klass.new
k.instance_eval { @secret }   #=> 99

Overloads:

  • #instance_eval(string[, filename [, lineno]]) ⇒ Object

    Returns:

  • #instance_eval {|| ... } ⇒ Object

    Yields:

    • ()

    Returns:



6729
6730
6731
 
# File 'eval.c', line 6729

VALUE
rb_obj_instance_eval(argc, argv, self)
int argc;

#instance_of? ⇒ Boolean

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

Returns:

  • (Boolean) 


428
429
430
 
# File 'object.c', line 428

VALUE
rb_obj_is_instance_of(obj, c)
VALUE obj, c;

#instance_variable_defined?(symbol) ⇒ Boolean

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:

  • (Boolean) 


2048
2049
2050
 
# File 'object.c', line 2048

static VALUE
rb_obj_ivar_defined(obj, iv)
VALUE obj, iv;

#instance_variable_get(symbol) ⇒ Object

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

Returns:



1986
1987
1988
 
# File 'object.c', line 1986

static VALUE
rb_obj_ivar_get(obj, iv)
VALUE obj, iv;

#instance_variable_set(symbol, obj) ⇒ Object

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:



2018
2019
2020
 
# File 'object.c', line 2018

static VALUE
rb_obj_ivar_set(obj, iv, val)
VALUE obj, iv, val;

#instance_variables ⇒ Object

#is_a? ⇒ Boolean #kind_of? ⇒ Boolean

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

Overloads:

  • #is_a? ⇒ Boolean

    Returns:

    • (Boolean)
  • #kind_of? ⇒ Boolean

    Returns:

    • (Boolean) 


472
473
474
 
# File 'object.c', line 472

VALUE
rb_obj_is_kind_of(obj, c)
VALUE obj, c;

#is_a? ⇒ Boolean #kind_of? ⇒ Boolean

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

Overloads:

  • #is_a? ⇒ Boolean

    Returns:

    • (Boolean)
  • #kind_of? ⇒ Boolean

    Returns:

    • (Boolean) 


472
473
474
 
# File 'object.c', line 472

VALUE
rb_obj_is_kind_of(obj, c)
VALUE obj, c;

#method(sym) ⇒ Object

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"



9095
9096
9097
 
# File 'eval.c', line 9095

static VALUE
rb_obj_method(obj, vid)
VALUE obj;

#methods ⇒ Array

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

Returns:



1869
1870
1871
 
# File 'object.c', line 1869

static VALUE
rb_obj_methods(argc, argv, obj)
int argc;

#nil? ⇒ Boolean

call_seq:

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

Only the object nil responds true to nil?.

Returns:

  • (Boolean) 


1054
1055
1056
 
# File 'object.c', line 1054

static VALUE
rb_false(obj)
VALUE obj;

#hash ⇒ Fixnum

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:



1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
 
# File 'gc.c', line 1992

VALUE
rb_obj_id(VALUE obj)
{
    /*
     *                32-bit VALUE space
     *          MSB ------------------------ LSB
     *  false   00000000000000000000000000000000
     *  true    00000000000000000000000000000010
     *  nil     00000000000000000000000000000100
     *  undef   00000000000000000000000000000110
     *  symbol  ssssssssssssssssssssssss00001110
     *  object  oooooooooooooooooooooooooooooo00        = 0 (mod sizeof(RVALUE))
     *  fixnum  fffffffffffffffffffffffffffffff1
     *
     *                    object_id space
     *                                       LSB
     *  false   00000000000000000000000000000000
     *  true    00000000000000000000000000000010
     *  nil     00000000000000000000000000000100
     *  undef   00000000000000000000000000000110
     *  symbol   000SSSSSSSSSSSSSSSSSSSSSSSSSSS0        S...S % A = 4 (S...S = s...s * A + 4)
     *  object   oooooooooooooooooooooooooooooo0        o...o % A = 0
     *  fixnum  fffffffffffffffffffffffffffffff1        bignum if required
     *
     *  where A = sizeof(RVALUE)/4
     *
     *  sizeof(RVALUE) is
     *  20 if 32-bit, double is 4-byte aligned
     *  24 if 32-bit, double is 8-byte aligned
     *  40 if 64-bit
     */
    if (TYPE(obj) == T_SYMBOL) {
        return (SYM2ID(obj) * sizeof(RVALUE) + (4 << 2)) | FIXNUM_FLAG;
    }
    if (SPECIAL_CONST_P(obj)) {
        return LONG2NUM((long)obj);
    }
    return (VALUE)((long)obj|FIXNUM_FLAG);
}

#private_methods(all = true) ⇒ Array

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:



1927
1928
1929
 
# File 'object.c', line 1927

static VALUE
rb_obj_private_methods(argc, argv, obj)
int argc;

#protected_methods(all = true) ⇒ Array

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:



1903
1904
1905
 
# File 'object.c', line 1903

static VALUE
rb_obj_protected_methods(argc, argv, obj)
int argc;

#public_methods(all = true) ⇒ Array

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.

Returns:



1951
1952
1953
 
# File 'object.c', line 1951

static VALUE
rb_obj_public_methods(argc, argv, obj)
int argc;

#remove_instance_variable(symbol) ⇒ Object (private)

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:



1165
1166
1167
 
# File 'variable.c', line 1165

VALUE
rb_obj_remove_instance_variable(obj, name)
VALUE obj, name;

#respond_to?(symbol, include_private = false) ⇒ Boolean

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.

Returns:

  • (Boolean) 


4207
4208
4209
 
# File 'eval.c', line 4207

static VALUE
obj_respond_to(argc, argv, obj)
int argc;

#send(symbol[, args...]) ⇒ Object #__send__(symbol[, args...]) ⇒ Object

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"

Overloads:



6098
6099
6100
 
# File 'eval.c', line 6098

static VALUE
rb_f_send(argc, argv, recv)
int argc;

#singleton_method_added ⇒ Object (private)

Not documented



630
631
632
633
634
 
# File 'object.c', line 630

static VALUE
rb_obj_dummy()
{
    return Qnil;
}

#singleton_method_removed ⇒ Object (private)

Not documented



630
631
632
633
634
 
# File 'object.c', line 630

static VALUE
rb_obj_dummy()
{
    return Qnil;
}

#singleton_method_undefined ⇒ Object (private)

Not documented



630
631
632
633
634
 
# File 'object.c', line 630

static VALUE
rb_obj_dummy()
{
    return Qnil;
}

#singleton_methods ⇒ Object

#taint ⇒ Object

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:



661
662
663
 
# File 'object.c', line 661

VALUE
rb_obj_taint(obj)
VALUE obj;

#tainted? ⇒ Boolean

Returns true if the object is tainted.

Returns:

  • (Boolean) 


643
644
645
 
# File 'object.c', line 643

VALUE
rb_obj_tainted(obj)
VALUE obj;

#to_a ⇒ Array

Returns an array representation of obj. For objects of class Object and others that don’t explicitly override the method, the return value is an array containing self. However, this latter behavior will soon be obsolete.

self.to_a       #=> -:1: warning: default `to_a' will be obsolete
"hello".to_a    #=> ["hello"]
Time.new.to_a   #=> [39, 54, 8, 9, 4, 2003, 3, 99, true, "CDT"]

Returns:



294
295
296
 
# File 'object.c', line 294

static VALUE
rb_any_to_a(obj)
VALUE obj;

#to_s ⇒ String

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.”

Returns:



313
314
315
 
# File 'object.c', line 313

VALUE
rb_any_to_s(obj)
VALUE obj;

#type ⇒ Class

Deprecated synonym for Object#class.

Returns:



133
134
135
 
# File 'object.c', line 133

VALUE
rb_obj_type(obj)
VALUE obj;

#untaint ⇒ Object

Removes the taint from obj.

Returns:



683
684
685
 
# File 'object.c', line 683

VALUE
rb_obj_untaint(obj)
VALUE obj;