Class: Object

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

Overview

Document-class: Object

Object is the root of Ruby's class hierarchy. Its methods are available to all classes 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).

Constant Summary collapse

SCRIPT_LINES__ =

When a Hash is assigned to SCRIPT_LINES__ the contents of files loaded after the assignment will be added as an Array of lines with the file name as the key.

Qnil
NIL =

An alias of nil

Qnil
TRUE =

An alias of true

Qtrue
FALSE =

An alias of false

Qfalse
RUBY_VERSION =

The running version of ruby

MKSTR(version)
RUBY_RELEASE_DATE =

The date this ruby was released

MKSTR(release_date)
RUBY_PLATFORM =

The platform for this ruby

MKSTR(platform)
RUBY_PATCHLEVEL =

The patchlevel for this ruby. If this is a development build of ruby the patchlevel will be -1

INT2FIX(RUBY_PATCHLEVEL)
RUBY_REVISION =

The SVN revision for this ruby.

INT2FIX(RUBY_REVISION)
RUBY_DESCRIPTION =

The full ruby version string, like ruby -v prints'

MKSTR(description)
MKSTR(copyright)
RUBY_ENGINE =

The engine or interpreter this ruby uses.

ruby_engine_name = MKSTR(engine)
TOPLEVEL_BINDING =

The Binding of the top level scope

rb_binding_new()
STDIN =

Holds the original stdin

rb_stdin
STDOUT =

Holds the original stdout

rb_stdout
STDERR =

Holds the original stderr

rb_stderr
ARGF =

ARGF is a stream designed for use in scripts that process files given as command-line arguments or passed in via STDIN.

See ARGF (the class) for more details.

argf
ENV =

ENV is a Hash-like accessor for environment variables.

See ENV (the class) for more details.

envtbl
DATA =

DATA is a File that contains the data section of the executed file. To create a data section use __END__:

$ cat t.rb
puts DATA.gets
__END__
hello world!

$ ruby t.rb
hello world!

f
ARGV =

ARGV contains the command line arguments used to run ruby with the first value containing the name of the executable.

A library like OptionParser can be used to process command-line arguments.

rb_argv

Instance Method Summary collapse

Methods included from Kernel

#Array, #Complex, #Float, #Integer, #Rational, #String, #__callee__, #__method__, #`, #abort, #at_exit, #autoload, #autoload?, #binding, #block_given?, #callcc, #caller, #catch, #chomp, #chop, #eval, #exec, #exit, #exit!, #fail, #fork, #format, #gets, #global_variables, #gsub, #iterator?, #lambda, #load, #local_variables, #loop, #open, #p, #print, #printf, #proc, #putc, #puts, #raise, #rand, #readline, #readlines, #require, #require_relative, #select, #set_trace_func, #sleep, #spawn, #sprintf, #srand, #sub, #syscall, #system, #test, #throw, #trace_var, #trap, #untrace_var, #warn

Instance Method Details

#!~ ⇒ Object

Returns true if two objects do not match (using the =~ method), otherwise false.




# File 'object.c'

static VALUE
rb_obj_not_match(VALUE obj1, VALUE obj2)
{
    VALUE result = rb_funcall(obj1, id_match, 1, obj2);
    return RTEST(result) ? Qfalse : Qtrue;
}

#<=>(other) ⇒ 0?

Returns 0 if obj === other, otherwise nil.

Returns:

  • (0, nil) 



# File 'object.c'

static VALUE
rb_obj_cmp(VALUE obj1, VALUE obj2)
{
    if (obj1 == obj2 || rb_equal(obj1, obj2))
    return INT2FIX(0);
    return Qnil;
}

#===(other) ⇒ Boolean

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

Returns:

  • (Boolean) 



# File 'object.c'

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

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

#=~(other) ⇒ nil

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

Returns:

  • (nil) 



# File 'object.c'

static VALUE
rb_obj_match(VALUE obj1, VALUE obj2)
{
    return Qnil;
}

#assert_Qundef ⇒ Object

:nodoc:




# File 'parse.c'

static VALUE
ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
{
StringValue(msg);
if (obj == Qundef) {
    rb_raise(rb_eArgError, "%s", RSTRING_PTR(msg));
}

#class ⇒ Class

Returns the class of obj. 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(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(VALUE obj)
{
VALUE clone;

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

#define_singleton_method(symbol, method) ⇒ Object #define_singleton_method(symbol) { ... } ⇒ Proc

Defines a singleton method in the receiver. The method parameter can be a Proc, a Method or an UnboundMethod object. If a block is specified, it is used as the method body.

class A
  class << self
    def class_name
      to_s
    end
  end
end
A.define_singleton_method(:who_am_i) do
  "I am: #{class_name}"
end
A.who_am_i   # ==> "I am: A"

guy = "Bob"
guy.define_singleton_method(:hello) { "#{self}: Hello there!" }
guy.hello    #=>  "Bob: Hello there!"

Overloads:

  • #define_singleton_method(symbol) { ... } ⇒ Proc

    Yields:

    Returns:




# File 'proc.c'

static VALUE
rb_obj_define_method(int argc, VALUE *argv, VALUE obj)
{
    VALUE klass = rb_singleton_class(obj);

    return rb_mod_define_method(argc, argv, klass);
}

#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(int argc, VALUE *argv, VALUE self)
{
VALUE out;

if (argc == 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 descendant classes. While clone is used to duplicate an object, including its internal state, dup typically uses the class of the descendant 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(VALUE obj)
{
VALUE dup;

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

#to_enum(method = :each, *args) ⇒ Object #enum_for(method = :each, *args) ⇒ Object

Creates a new Enumerator which will enumerate by on calling method on obj.

method

the method to call on obj to generate the enumeration

args

arguments that will be passed in method in addition to the item itself. Note that the number of args must not exceed the number expected by method

Example

str = "xyz"

enum = str.enum_for(:each_byte)
enum.each { |b| puts b }
# => 120
# => 121
# => 122

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




# File 'enumerator.c'

static VALUE
obj_to_enum(int argc, VALUE *argv, VALUE obj)
{
VALUE meth = sym_each;

if (argc > 0) {
--argc;
meth = *argv++;
}

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

Overloads:

  • #==(other) ⇒ Boolean

    Returns:

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

    Returns:

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

    Returns:

    • (Boolean) 



# File 'object.c'

VALUE
rb_obj_equal(VALUE obj1, VALUE 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(int argc, VALUE *argv, VALUE obj)
{
int i;

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

#freeze ⇒ Object

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

This method returns self.

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

produces:

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

Returns:




# File 'object.c'

VALUE
rb_obj_freeze(VALUE obj)
{
if (!OBJ_FROZEN(obj)) {
if (rb_safe_level() >= 4 && !OBJ_UNTRUSTED(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'

VALUE
rb_obj_frozen_p(VALUE obj)
{
if (OBJ_FROZEN(obj)) return Qtrue;
if (SPECIAL_CONST_P(obj)) {
if (!immediate_frozen_tbl) return Qfalse;
if (st_lookup(immediate_frozen_tbl, obj, 0)) return Qtrue;
}

#hash ⇒ Object

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.

"waffle".hash #=> -910576647




# File 'object.c'

VALUE
rb_obj_hash(VALUE obj)
{
    VALUE oid = rb_obj_id(obj);
    st_index_t h = rb_hash_end(rb_hash_start(NUM2LONG(oid)));
    return LONG2FIX(h);
}

#initialize_clone ⇒ Object

:nodoc:




# File 'object.c'

VALUE
rb_obj_init_dup_clone(VALUE obj, VALUE orig)
{
    rb_funcall(obj, id_init_copy, 1, orig);
    return obj;
}

#initialize_copy ⇒ Object

:nodoc:




# File 'object.c'

VALUE
rb_obj_init_copy(VALUE obj, VALUE 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");
}

#initialize_dup ⇒ Object

:nodoc:




# File 'object.c'

VALUE
rb_obj_init_dup_clone(VALUE obj, VALUE orig)
{
    rb_funcall(obj, id_init_copy, 1, orig);
    return obj;
}

#inspect ⇒ String

Returns a string containing a human-readable representation of obj. If not overridden and no instance variables, uses the to_s method to generate the string. 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:




# File 'object.c'

static VALUE
rb_obj_inspect(VALUE obj)
{
    if (TYPE(obj) == T_OBJECT && rb_obj_basic_to_s_p(obj)) {
        int has_ivar = 0;
        VALUE *ptr = ROBJECT_IVPTR(obj);
        long len = ROBJECT_NUMIV(obj);
        long i;

        for (i = 0; i < len; i++) {
if (ptr[i] != Qundef) {
    has_ivar = 1;
    break;
}

#instance_of? ⇒ Boolean

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

class A;     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

Returns:

  • (Boolean) 



# File 'object.c'

VALUE
rb_obj_is_instance_of(VALUE obj, VALUE 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(VALUE obj, VALUE 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(VALUE obj, VALUE 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(VALUE obj, VALUE iv, VALUE 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(VALUE obj)
{
    VALUE ary;

    ary = rb_ary_new();
    rb_ivar_foreach(obj, ivar_i, ary);
    return 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.is_a? A          #=> true
b.is_a? B          #=> true
b.is_a? C          #=> false
b.is_a? M          #=> true

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(VALUE obj, VALUE 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.is_a? A          #=> true
b.is_a? B          #=> true
b.is_a? C          #=> false
b.is_a? M          #=> true

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(VALUE obj, VALUE 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 'proc.c'

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

#methods ⇒ Object

#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(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 (SYMBOL_P(obj)) {
    return (SYM2ID(obj) * sizeof(RVALUE) + (4 << 2)) | FIXNUM_FLAG;
}

#private_methods ⇒ Object

#protected_methods ⇒ Object

#public_method(sym) ⇒ Object

Similar to method, searches public method only.




# File 'proc.c'

VALUE
rb_obj_public_method(VALUE obj, VALUE vid)
{
    return mnew(CLASS_OF(obj), obj, rb_to_id(vid), rb_cMethod, TRUE);
}

#public_methods ⇒ Object

#public_send(symbol[, args...]) ⇒ Object

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

Returns:




# File 'vm_eval.c'

VALUE
rb_f_public_send(int argc, VALUE *argv, VALUE recv)
{
    return send_internal(argc, argv, recv, CALL_PUBLIC);
}

#rawVALUE ⇒ Object

:nodoc:




# File 'parse.c'

static VALUE
ripper_value(VALUE self, VALUE obj)
{
    return ULONG2NUM(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(VALUE obj, VALUE name)
{
VALUE val = Qnil;
const ID id = rb_to_id(name);
st_data_t n, v;
struct st_table *iv_index_tbl;
st_data_t index;

if (!OBJ_UNTRUSTED(obj) && rb_safe_level() >= 4)
	rb_raise(rb_eSecurityError, "Insecure: can't modify instance variable");
rb_check_frozen(obj);
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.

If the method is not implemented, as Process.fork on Windows, File.lchmod on GNU/Linux, etc., false is returned.

If the method is not defined, respond_to_missing? method is called and the result is returned.

Returns:

  • (Boolean) 



# File 'vm_method.c'

static VALUE
obj_respond_to(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 (basic_obj_respond_to(obj, id, !RTEST(priv)))
    return Qtrue;
    return Qfalse;
}

#respond_to_missing?(symbol, include_private) ⇒ Boolean

Hook method to return whether the obj can respond to id method or not.

See #respond_to?.

Returns:

  • (Boolean) 



# File 'vm_method.c'

static VALUE
obj_respond_to_missing(VALUE obj, VALUE mid, VALUE priv)
{
    return Qfalse;
}

#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 'vm_eval.c'

VALUE
rb_f_send(int argc, VALUE *argv, VALUE recv)
{
    return send_internal(argc, argv, recv, CALL_FCALL);
}

#singleton_class ⇒ Class

Returns the singleton class of obj. This method creates a new singleton class if obj does not have it.

If obj is nil, true, or false, it returns NilClass, TrueClass, or FalseClass, respectively. If obj is a Fixnum or a Symbol, it raises a TypeError.

Object.new.singleton_class  #=> #<Class:#<Object:0xb7ce1e24>>
String.singleton_class      #=> #<Class:String>
nil.singleton_class         #=> NilClass

Returns:




# File 'object.c'

static VALUE
rb_obj_singleton_class(VALUE obj)
{
    return rb_singleton_class(obj);
}

#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. Only public and protected singleton methods are returned.

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(int argc, VALUE *argv, VALUE obj)
{
VALUE recur, ary, klass;
st_table *list;

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(VALUE obj)
{
rb_secure(4);
if (!OBJ_TAINTED(obj)) {
rb_check_frozen(obj);
OBJ_TAINT(obj);
}

#tainted? ⇒ Boolean

Returns true if the object is tainted.

Returns:

  • (Boolean) 



# File 'object.c'

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

#tap {|x| ... } ⇒ Object

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

Yields:

  • (x)

Returns:




# File 'object.c'

VALUE
rb_obj_tap(VALUE obj)
{
    rb_yield(obj);
    return obj;
}

#to_enum(method = :each, *args) ⇒ Object #enum_for(method = :each, *args) ⇒ Object

Creates a new Enumerator which will enumerate by on calling method on obj.

method

the method to call on obj to generate the enumeration

args

arguments that will be passed in method in addition to the item itself. Note that the number of args must not exceed the number expected by method

Example

str = "xyz"

enum = str.enum_for(:each_byte)
enum.each { |b| puts b }
# => 120
# => 121
# => 122

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




# File 'enumerator.c'

static VALUE
obj_to_enum(int argc, VALUE *argv, VALUE obj)
{
VALUE meth = sym_each;

if (argc > 0) {
--argc;
meth = *argv++;
}

#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(VALUE obj)
{
    const char *cname = rb_obj_classname(obj);
    VALUE str;

    str = rb_sprintf("#<%s:%p>", cname, (void*)obj);
    OBJ_INFECT(str, obj);

    return str;
}

#trust ⇒ Object

Removes the untrusted mark from obj.

Returns:




# File 'object.c'

VALUE
rb_obj_trust(VALUE obj)
{
rb_secure(3);
if (OBJ_UNTRUSTED(obj)) {
rb_check_frozen(obj);
FL_UNSET(obj, FL_UNTRUSTED);
}

#untaint ⇒ Object

Removes the taint from obj.

Returns:




# File 'object.c'

VALUE
rb_obj_untaint(VALUE obj)
{
rb_secure(3);
if (OBJ_TAINTED(obj)) {
rb_check_frozen(obj);
FL_UNSET(obj, FL_TAINT);
}

#untrust ⇒ Object

Marks obj as untrusted.

Returns:




# File 'object.c'

VALUE
rb_obj_untrust(VALUE obj)
{
rb_secure(4);
if (!OBJ_UNTRUSTED(obj)) {
rb_check_frozen(obj);
OBJ_UNTRUST(obj);
}

#untrusted? ⇒ Boolean

Returns true if the object is untrusted.

Returns:

  • (Boolean) 



# File 'object.c'

VALUE
rb_obj_untrusted(VALUE obj)
{
    if (OBJ_UNTRUSTED(obj))
    return Qtrue;
    return Qfalse;
}

#validate_object ⇒ Object

:nodoc:




# File 'parse.c'

static VALUE
ripper_validate_object(VALUE self, VALUE x)
{
if (x == Qfalse) return x;
if (x == Qtrue) return x;
if (x == Qnil) return x;
if (x == Qundef)
    rb_raise(rb_eArgError, "Qundef given");
if (FIXNUM_P(x)) return x;
if (SYMBOL_P(x)) return x;
if (!rb_is_pointer_to_heap(x))
    rb_raise(rb_eArgError, "invalid pointer: %p", x);
switch (TYPE(x)) {
  case T_STRING:
  case T_OBJECT:
  case T_ARRAY:
  case T_BIGNUM:
  case T_FLOAT:
    return x;
  case T_NODE:
if (nd_type(x) != NODE_LASGN) {
    rb_raise(rb_eArgError, "NODE given: %p", x);
}