Class: Object

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

Constant Summary collapse

NIL = 
Qnil
TRUE = 
Qtrue
FALSE = 
Qfalse
RUBY_VERSION = 
v
RUBY_RELEASE_DATE = 
d
RUBY_PLATFORM = 
p
RUBY_PATCHLEVEL = 
INT2FIX(RUBY_PATCHLEVEL)
VERSION =

obsolete constants

v
RELEASE_DATE = 
d
PLATFORM = 
p
MatchingData = 
rb_cMatch
STDIN =

constants to hold original stdin/stdout/stderr

rb_stdin
STDOUT = 
rb_stdout
STDERR = 
rb_stderr
ARGF = 
argf
DATA = 
f
ARGV = 
rb_argv
TOPLEVEL_BINDING = 
rb_f_binding(ruby_top_self)
ENV = 
envtbl

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, #exec, #exit, #exit!, #fail, #fork, #format, #getc, #gets, #global_variables, #gsub, #gsub!, #iterator?, #lambda, #load, #local_variables, #loop, #method_missing, #open, #p, #print, #printf, #proc, #putc, #puts, #raise, #rand, #readline, #readlines, #require, #scan, #select, #set_trace_func, #sleep, #split, #sprintf, #srand, #sub, #sub!, #syscall, #system, #test, #throw, #trace_var, #trap, #untrace_var, #warn

Constructor Details

#initialize ⇒ Object

Not documented




# File 'object.c'

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) 



# File 'object.c'

static VALUE
rb_obj_equal(obj1, obj2)
    VALUE obj1, obj2;
{
    if (obj1 == obj2) return Qtrue;
    return Qfalse;
}

#===(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) 



# File 'object.c'

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

    if (obj1 == obj2) return Qtrue;
    result = rb_funcall(obj1, id_eq, 1, obj2);
    if (RTEST(result)) return Qtrue;
    return Qfalse;
}

#=~(other) ⇒ false

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

Returns:

  • (false) 



# File 'object.c'

static VALUE
rb_obj_pattern_match(obj1, obj2)
    VALUE obj1, obj2;
{
    return Qfalse;
}

#__id__ ⇒ Object

call-seq:

obj.__id__       => fixnum
obj.object_id    => fixnum

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.




# File 'gc.c'

/*
 *  call-seq:
 *     obj.hash    => fixnum
 *  
 *  Generates a <code>Fixnum</code> hash value for this object. This
 *  function must have the property that <code>a.eql?(b)</code> implies
 *  <code>a.hash == b.hash</code>. The hash value is used by class
 *  <code>Hash</code>. Any hash value that exceeds the capacity of a
 *  <code>Fixnum</code> will be truncated before being used.
 */

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;
}

#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:




# File 'eval.c'

static VALUE
rb_f_send(argc, argv, recv)
    int argc;
    VALUE *argv;
    VALUE recv;
{
    VALUE vid;

    if (argc == 0) rb_raise(rb_eArgError, "no method name given");

    vid = *argv++; argc--;
    PUSH_ITER(rb_block_given_p()?ITER_PRE:ITER_NOT);
    vid = rb_call(CLASS_OF(recv), recv, rb_to_id(vid), argc, argv, 1, Qundef);
    POP_ITER();

    return vid;
}

#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:




# File 'object.c'

VALUE
rb_obj_class(obj)
    VALUE obj;
{
    return rb_class_real(CLASS_OF(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:




# File 'object.c'

VALUE
rb_obj_clone(obj)
VALUE obj;
{
VALUE clone;

if (rb_special_const_p(obj)) {
    rb_raise(rb_eTypeError, "can't clone %s", rb_obj_classname(obj));
}

#display(port = $>) ⇒ nil

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

Returns:

  • (nil) 



# File 'io.c'

static VALUE
rb_obj_display(argc, argv, self)
int argc;
VALUE *argv;
VALUE self;
{
VALUE out;

if (rb_scan_args(argc, argv, "01", &out) == 0) {
out = rb_stdout;
}

#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:




# File 'object.c'

VALUE
rb_obj_dup(obj)
VALUE obj;
{
VALUE dup;

if (rb_special_const_p(obj)) {
    rb_raise(rb_eTypeError, "can't dup %s", rb_obj_classname(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) 



# File 'object.c'

static VALUE
rb_obj_equal(obj1, obj2)
    VALUE obj1, obj2;
{
    if (obj1 == obj2) return Qtrue;
    return Qfalse;
}

#==(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) 



# File 'object.c'

static VALUE
rb_obj_equal(obj1, obj2)
    VALUE obj1, obj2;
{
    if (obj1 == obj2) return Qtrue;
    return Qfalse;
}

#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:




# File 'eval.c'

static VALUE
rb_obj_extend(argc, argv, obj)
int argc;
VALUE *argv;
VALUE obj;
{
int i;

if (argc == 0) {
rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
}

#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:




# File 'object.c'

VALUE
rb_obj_freeze(obj)
VALUE obj;
{
if (!OBJ_FROZEN(obj)) {
if (rb_safe_level() >= 4 && !OBJ_TAINTED(obj)) {
    rb_raise(rb_eSecurityError, "Insecure: can't freeze object");
}

#frozen? ⇒ Boolean

Returns the freeze status of obj.

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

Returns:

  • (Boolean) 



# File 'object.c'

static VALUE
rb_obj_frozen_p(obj)
    VALUE obj;
{
    if (OBJ_FROZEN(obj)) return Qtrue;
    return Qfalse;
}

#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:




# File 'gc.c'

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;
}

#id ⇒ Fixnum

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

Returns:




# File 'object.c'

VALUE
rb_obj_id_obsolete(obj)
    VALUE obj;
{
    rb_warn("Object#id will be deprecated; use Object#object_id");
    return rb_obj_id(obj);
}

#initialize_copy ⇒ Object

:nodoc:




# File 'object.c'

VALUE
rb_obj_init_copy(obj, orig)
VALUE obj, orig;
{
if (obj == orig) return obj;
rb_check_frozen(obj);
if (TYPE(obj) != TYPE(orig) || rb_obj_class(obj) != rb_obj_class(orig)) {
rb_raise(rb_eTypeError, "initialize_copy should take same class object");
}

#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:




# File 'object.c'

static VALUE
rb_obj_inspect(obj)
VALUE obj;
{
if (TYPE(obj) == T_OBJECT
&& ROBJECT(obj)->iv_tbl
&& ROBJECT(obj)->iv_tbl->num_entries > 0) {
VALUE str;
size_t len;
char *c;

c = rb_obj_classname(obj);
if (rb_inspecting_p(obj)) {
    len = strlen(c)+10+16+1;
    str = rb_str_new(0, len); /* 10:tags 16:addr 1:nul */
    snprintf(RSTRING(str)->ptr, len, "#<%s:0x%lx ...>", c, obj);
    RSTRING(str)->len = strlen(RSTRING(str)->ptr);
    return str;
}

#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:




# File 'eval.c'

VALUE
rb_obj_instance_eval(argc, argv, self)
int argc;
VALUE *argv;
VALUE self;
{
VALUE klass;

if (SPECIAL_CONST_P(self)) {
klass = Qnil;
}

#instance_of? ⇒ Boolean

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

Returns:

  • (Boolean) 



# File 'object.c'

VALUE
rb_obj_is_instance_of(obj, c)
VALUE obj, c;
{
switch (TYPE(c)) {
  case T_MODULE:
  case T_CLASS:
  case T_ICLASS:
break;
  default:
rb_raise(rb_eTypeError, "class or module required");
}

#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) 



# File 'object.c'

static VALUE
rb_obj_ivar_defined(obj, iv)
VALUE obj, iv;
{
ID id = rb_to_id(iv);

if (!rb_is_instance_id(id)) {
rb_name_error(id, "`%s' is not allowed as an instance variable name", rb_id2name(id));
}

#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:




# File 'object.c'

static VALUE
rb_obj_ivar_get(obj, iv)
VALUE obj, iv;
{
ID id = rb_to_id(iv);

if (!rb_is_instance_id(id)) {
rb_name_error(id, "`%s' is not allowed as an instance variable name", rb_id2name(id));
}

#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:




# File 'object.c'

static VALUE
rb_obj_ivar_set(obj, iv, val)
VALUE obj, iv, val;
{
ID id = rb_to_id(iv);

if (!rb_is_instance_id(id)) {
rb_name_error(id, "`%s' is not allowed as an instance variable name", rb_id2name(id));
}

#instance_variables ⇒ Array

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:




# File 'object.c'

VALUE
rb_obj_instance_variables(obj)
   VALUE obj;
{
   VALUE ary;

   ary = rb_ary_new();
   switch (TYPE(obj)) {
     case T_OBJECT:
     case T_CLASS:
     case T_MODULE:
if (ROBJECT(obj)->iv_tbl) {
    st_foreach_safe(ROBJECT(obj)->iv_tbl, ivar_i, ary);
}

#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) 



# File 'object.c'

VALUE
rb_obj_is_kind_of(obj, c)
VALUE obj, c;
{
VALUE cl = CLASS_OF(obj);

switch (TYPE(c)) {
  case T_MODULE:
  case T_CLASS:
  case T_ICLASS:
break;

  default:
rb_raise(rb_eTypeError, "class or module required");
}

#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) 



# File 'object.c'

VALUE
rb_obj_is_kind_of(obj, c)
VALUE obj, c;
{
VALUE cl = CLASS_OF(obj);

switch (TYPE(c)) {
  case T_MODULE:
  case T_CLASS:
  case T_ICLASS:
break;

  default:
rb_raise(rb_eTypeError, "class or module required");
}

#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"




# File 'eval.c'

static VALUE
rb_obj_method(obj, vid)
    VALUE obj;
    VALUE vid;
{
    return mnew(CLASS_OF(obj), obj, rb_to_id(vid), rb_cMethod);
}

#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:




# File 'object.c'

static VALUE
rb_obj_methods(argc, argv, obj)
int argc;
VALUE *argv;
VALUE obj;
{
  retry:
if (argc == 0) {
VALUE args[1];

args[0] = Qtrue;
return rb_class_instance_methods(1, args, CLASS_OF(obj));
}

#nil? ⇒ Object

call_seq:

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

Only the object nil responds true to nil?.




# File 'object.c'

static VALUE
rb_false(obj)
    VALUE obj;
{
    return Qfalse;
}

#__id__ ⇒ Fixnum #object_id ⇒ Fixnum

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.

Overloads:




# File 'gc.c'

/*
 *  call-seq:
 *     obj.hash    => fixnum
 *  
 *  Generates a <code>Fixnum</code> hash value for this object. This
 *  function must have the property that <code>a.eql?(b)</code> implies
 *  <code>a.hash == b.hash</code>. The hash value is used by class
 *  <code>Hash</code>. Any hash value that exceeds the capacity of a
 *  <code>Fixnum</code> will be truncated before being used.
 */

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;
}

#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:




# File 'object.c'

static VALUE
rb_obj_private_methods(argc, argv, obj)
int argc;
VALUE *argv;
VALUE obj;
{
if (argc == 0) {        /* hack to stop warning */
VALUE args[1];

args[0] = Qtrue;
return rb_class_private_instance_methods(1, args, CLASS_OF(obj));
}

#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:




# File 'object.c'

static VALUE
rb_obj_protected_methods(argc, argv, obj)
int argc;
VALUE *argv;
VALUE obj;
{
if (argc == 0) {        /* hack to stop warning */
VALUE args[1];

args[0] = Qtrue;
return rb_class_protected_instance_methods(1, args, CLASS_OF(obj));
}

#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:




# File 'object.c'

static VALUE
rb_obj_public_methods(argc, argv, obj)
int argc;
VALUE *argv;
VALUE obj;
{
if (argc == 0) {        /* hack to stop warning */
VALUE args[1];

args[0] = Qtrue;
return rb_class_public_instance_methods(1, args, CLASS_OF(obj));
}

#remove_instance_variable(symbol) ⇒ Object

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:




# File 'object.c'

VALUE
rb_obj_remove_instance_variable(obj, name)
VALUE obj, name;
{
VALUE val = Qnil;
ID id = rb_to_id(name);

if (!OBJ_TAINTED(obj) && rb_safe_level() >= 4)
	rb_raise(rb_eSecurityError, "Insecure: can't modify instance variable");
if (OBJ_FROZEN(obj)) rb_error_frozen("object");
if (!rb_is_instance_id(id)) {
	rb_name_error(id, "`%s' is not allowed as an instance variable name", rb_id2name(id));
}

#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) 



# File 'eval.c'

static VALUE
obj_respond_to(argc, argv, obj)
int argc;
VALUE *argv;
VALUE obj;
{
VALUE mid, priv;
ID id;

rb_scan_args(argc, argv, "11", &mid, &priv);
id = rb_to_id(mid);
if (rb_method_boundp(CLASS_OF(obj), id, !RTEST(priv))) {
return Qtrue;
}

#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:




# File 'eval.c'

static VALUE
rb_f_send(argc, argv, recv)
    int argc;
    VALUE *argv;
    VALUE recv;
{
    VALUE vid;

    if (argc == 0) rb_raise(rb_eArgError, "no method name given");

    vid = *argv++; argc--;
    PUSH_ITER(rb_block_given_p()?ITER_PRE:ITER_NOT);
    vid = rb_call(CLASS_OF(recv), recv, rb_to_id(vid), argc, argv, 1, Qundef);
    POP_ITER();

    return vid;
}

#singleton_method_added(symbol) ⇒ Object

Invoked as a callback whenever a singleton method is added to the receiver.

module Chatty
  def Chatty.singleton_method_added(id)
    puts "Adding #{id.id2name}"
  end
  def self.one()     end
  def two()          end
  def Chatty.three() end
end

produces:

Adding singleton_method_added
Adding one
Adding three




# File 'object.c'

/*
 * Not documented
 */

static VALUE
rb_obj_dummy()
{
    return Qnil;
}

#singleton_method_removed(symbol) ⇒ Object

Invoked as a callback whenever a singleton method is removed from the receiver.

module Chatty
  def Chatty.singleton_method_removed(id)
    puts "Removing #{id.id2name}"
  end
  def self.one()     end
  def two()          end
  def Chatty.three() end
  class <<self
    remove_method :three
    remove_method :one
  end
end

produces:

Removing three
Removing one




# File 'object.c'

/*
 * Not documented
 */

static VALUE
rb_obj_dummy()
{
    return Qnil;
}

#singleton_method_undefined(symbol) ⇒ Object

Invoked as a callback whenever a singleton method is undefined in the receiver.

module Chatty
  def Chatty.singleton_method_undefined(id)
    puts "Undefining #{id.id2name}"
  end
  def Chatty.one()   end
  class << self
     undef_method(:one)
  end
end

produces:

Undefining one




# File 'object.c'

/*
 * Not documented
 */

static VALUE
rb_obj_dummy()
{
    return Qnil;
}

#singleton_methods(all = true) ⇒ Array

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"]

Returns:




# File 'object.c'

VALUE
rb_obj_singleton_methods(argc, argv, obj)
int argc;
VALUE *argv;
VALUE obj;
{
VALUE recur, ary, klass;
st_table *list;

rb_scan_args(argc, argv, "01", &recur);
if (argc == 0) {
	recur = Qtrue;
}

#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:




# File 'object.c'

VALUE
rb_obj_taint(obj)
VALUE obj;
{
rb_secure(4);
if (!OBJ_TAINTED(obj)) {
if (OBJ_FROZEN(obj)) {
    rb_error_frozen("object");
}

#tainted? ⇒ Boolean

Returns true if the object is tainted.

Returns:

  • (Boolean) 



# File 'object.c'

VALUE
rb_obj_tainted(obj)
    VALUE obj;
{
    if (OBJ_TAINTED(obj))
    return Qtrue;
    return Qfalse;
}

#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:




# File 'object.c'

static VALUE
rb_any_to_a(obj)
    VALUE obj;
{
    rb_warn("default `to_a' will be obsolete");
    return rb_ary_new3(1, 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:




# File 'object.c'

VALUE
rb_any_to_s(obj)
    VALUE obj;
{
    char *cname = rb_obj_classname(obj);
    size_t len;
    VALUE str;

    len = strlen(cname)+6+16;
    str = rb_str_new(0, len); /* 6:tags 16:addr */
    snprintf(RSTRING(str)->ptr, len+1, "#<%s:0x%lx>", cname, obj);
    RSTRING(str)->len = strlen(RSTRING(str)->ptr);
    if (OBJ_TAINTED(obj)) OBJ_TAINT(str);

    return str;
}

#type ⇒ Class

Deprecated synonym for Object#class.

Returns:




# File 'object.c'

VALUE
rb_obj_type(obj)
    VALUE obj;
{
    rb_warn("Object#type is deprecated; use Object#class");
    return rb_class_real(CLASS_OF(obj));
}

#untaint ⇒ Object

Removes the taint from obj.

Returns:




# File 'object.c'

VALUE
rb_obj_untaint(obj)
VALUE obj;
{
rb_secure(3);
if (OBJ_TAINTED(obj)) {
if (OBJ_FROZEN(obj)) {
    rb_error_frozen("object");
}