class Object - Documentation for Ruby 4.0
Description: class Object: Object is the default root of all Ruby objects. Object inherits from BasicObject which allows creating alternate object hierarchies.
Keywords: ruby,class,Object

🔍

No recent searches

# class Object

`Object` is the default root of all Ruby objects. `Object` inherits from `BasicObject` which allows creating alternate object hierarchies. Methods on `Object` 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.

When referencing constants in classes inheriting from `Object` you do not need to use the full namespace. For example, referencing `File` inside `YourClass` will find the top-level `File` class.

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`).

## What’s Here

First, what’s elsewhere. Class Object:

- Inherits from class BasicObject.

- Includes module Kernel.

Here, class Object provides methods for:

- Querying

- Instance Variables

- Other

### Querying

- `!~`: Returns `true` if `self` does not match the given object, otherwise `false`.

- `<=>`: Returns 0 if `self` and the given object `object` are the same object, or if `self == object`; otherwise returns `nil`.

- `===`: Implements case equality, effectively the same as calling `==`.

- `eql?`: Implements hash equality, effectively the same as calling `==`.

- `kind_of?` (aliased as `is_a?`): Returns whether given argument is an ancestor of the singleton class of `self`.

- `instance_of?`: Returns whether `self` is an instance of the given class.

- `instance_variable_defined?`: Returns whether the given instance variable is defined in `self`.

- `method`: Returns the `Method` object for the given method in `self`.

- `methods`: Returns an array of symbol names of public and protected methods in `self`.

- `nil?`: Returns `false`. (Only `nil` responds `true` to method `nil?`.)

- `object_id`: Returns an integer corresponding to `self` that is unique for the current process

- `private_methods`: Returns an array of the symbol names of the private methods in `self`.

- `protected_methods`: Returns an array of the symbol names of the protected methods in `self`.

- `public_method`: Returns the `Method` object for the given public method in `self`.

- `public_methods`: Returns an array of the symbol names of the public methods in `self`.

- `respond_to?`: Returns whether `self` responds to the given method.

- `singleton_class`: Returns the singleton class of `self`.

- `singleton_method`: Returns the `Method` object for the given singleton method in `self`.

- `singleton_methods`: Returns an array of the symbol names of the singleton methods in `self`.

- `define_singleton_method`: Defines a singleton method in `self` for the given symbol method-name and block or proc.

- `extend`: Includes the given modules in the singleton class of `self`.

- `public_send`: Calls the given public method in `self` with the given argument.

- `send`: Calls the given method in `self` with the given argument.

### Instance Variables

- `instance_variable_get`: Returns the value of the given instance variable in `self`, or `nil` if the instance variable is not set.

- `instance_variable_set`: Sets the value of the given instance variable in `self` to the given object.

- `instance_variables`: Returns an array of the symbol names of the instance variables in `self`.

- `remove_instance_variable`: Removes the named instance variable from `self`.

### Other

- `clone`: Returns a shallow copy of `self`, including singleton class and frozen state.

- `define_singleton_method`: Defines a singleton method in `self` for the given symbol method-name and block or proc.

- `display`: Prints `self` to the given `IO` stream or `$stdout`.

- `dup`: Returns a shallow unfrozen copy of `self`.

- `enum_for` (aliased as `to_enum`): Returns an `Enumerator` for `self` using the using the given method, arguments, and block.

- `extend`: Includes the given modules in the singleton class of `self`.

- `freeze`: Prevents further modifications to `self`.

- `hash`: Returns the integer hash value for `self`.

- `inspect`: Returns a human-readable string representation of `self`.

- `itself`: Returns `self`.

- `method_missing`: Method called when an undefined method is called on `self`.

- `public_send`: Calls the given public method in `self` with the given argument.

- `send`: Calls the given method in `self` with the given argument.

- `to_s`: Returns a string representation of `self`.

### Constants

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.

ARGV

  `ARGV` contains the command line arguments used to run ruby.

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

CROSS_COMPILING

  Non-nil if configured for cross compiling.

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!

ENV

  `ENV` is a Hash-like accessor for environment variables.

  See `ENV` (the class) for more details.

Ripper

  This writes the prism ripper translation into the `Ripper` constant so that users can transparently use `Ripper` without any changes.

STDERR

  Holds the original stderr

STDIN

  Holds the original stdin

STDOUT

  Holds the original stdout

TOPLEVEL_BINDING

  The `Binding` of the top level scope

### Public Class Methods

yaml_tag (url)
Source

    # File ext/psych/lib/psych/core_ext.rb, line 3
    def self.yaml_tag url
      Psych.add_tag(url, self)
    end

### Public Instance Methods

obj !~ other → true or false
Source

    static VALUE
    rb_obj_not_match(VALUE obj1, VALUE obj2)
    {
        VALUE result = rb_funcall(obj1, id_match, 1, obj2);
        return rb_obj_not(result);
    }

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

self <=> other → 0 or nil
Source

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

Compares `self` and `other`.

Returns:

- `0`, if `self` and `other` are the same object, or if `self == other`.

- `nil`, otherwise.

Examples:

    o = Object.new
    o <=> o     # => 0
    o <=> o.dup # => nil

A class that includes module `Comparable` should override this method by defining an instance method that:

- Take one argument, `other`.

- Returns:

  - `-1`, if `self` is less than `other`.

  - `0`, if `self` is equal to `other`.

  - `1`, if `self` is greater than `other`.

  - `nil`, if the two values are incommensurate.

true === other → true or false
false === other → true or false
nil === other → true or false
Source

    #define case_equal rb_equal

Returns `true` or `false`.

Like `Object#==`, if `object` is an instance of `Object` (and not an instance of one of its many subclasses).

This method is commonly overridden by those subclasses, to provide meaningful semantics in `case` statements.

DelegateClass (superclass, &block)
Source

    # File lib/delegate.rb, line 395
    def DelegateClass(superclass, &block)
      klass = Class.new(Delegator)
      ignores = [*::Delegator.public_api, :to_s, :inspect, :=~, :!~, :===]
      protected_instance_methods = superclass.protected_instance_methods
      protected_instance_methods -= ignores
      public_instance_methods = superclass.public_instance_methods
      public_instance_methods -= ignores

      normal, special = public_instance_methods.partition { |m| m.match?(/\A[a-zA-Z]\w*[!\?]?\z/) }

      source = normal.map do |method|
        "def #{method}(...); __getobj__.#{method}(...); end"
      end

      protected_instance_methods.each do |method|
        source << "def #{method}(...); __getobj__.__send__(#{method.inspect}, ...); end"
      end

      klass.module_eval do
        def __getobj__ # :nodoc:
          unless defined?(@delegate_dc_obj)
            return yield if block_given?
            __raise__ ::ArgumentError, "not delegated"
          end
          @delegate_dc_obj
        end

        def __setobj__(obj)  # :nodoc:
          __raise__ ::ArgumentError, "cannot delegate to self" if self.equal?(obj)
          @delegate_dc_obj = obj
        end

        class_eval(source.join(";"), __FILE__, __LINE__)

        special.each do |method|
          define_method(method, Delegator.delegating_block(method))
        end

        protected(*protected_instance_methods)
      end

      klass.define_singleton_method :public_instance_methods do |all=true|
        super(all) | superclass.public_instance_methods
      end
      klass.define_singleton_method :protected_instance_methods do |all=true|
        super(all) | superclass.protected_instance_methods
      end
      klass.define_singleton_method :instance_methods do |all=true|
        super(all) | superclass.instance_methods
      end
      klass.define_singleton_method :public_instance_method do |name|
        super(name)
      rescue NameError
        raise unless self.public_instance_methods.include?(name)
        superclass.public_instance_method(name)
      end
      klass.define_singleton_method :instance_method do |name|
        super(name)
      rescue NameError
        raise unless self.instance_methods.include?(name)
        superclass.instance_method(name)
      end
      klass.module_eval(&block) if block
      return klass
    end

The primary interface to this library. Use to setup delegation when defining your class.

    class MyClass < DelegateClass(ClassToDelegateTo) # Step 1
      def initialize
        super(obj_of_ClassToDelegateTo)              # Step 2
      end
    end

or:

    MyClass = DelegateClass(ClassToDelegateTo) do    # Step 1
      def initialize
        super(obj_of_ClassToDelegateTo)              # Step 2
      end
    end

Here’s a sample of use from `Tempfile` which is really a `File` object with a few special rules about storage location and when the `File` should be deleted. That makes for an almost textbook perfect example of how to use delegation.

    class Tempfile < DelegateClass(File)
      # constant and class member data initialization...

      def initialize(basename, tmpdir=Dir::tmpdir)
        # build up file path/name in var tmpname...

        @tmpfile = File.open(tmpname, File::RDWR|File::CREAT|File::EXCL, 0600)

        # ...

        super(@tmpfile)

        # below this point, all methods of File are supported...
      end

      # ...
    end

Calls superclass method
Digest(name) → digest_subclass
Source

    # File ext/digest/lib/digest.rb, line 110
    def Digest(name)
      const = name.to_sym
      Digest::REQUIRE_MUTEX.synchronize {
        # Ignore autoload's because it is void when we have #const_missing
        Digest.const_missing(const)
      }
    rescue LoadError
      # Constants do not necessarily rely on digest/*.
      if Digest.const_defined?(const)
        Digest.const_get(const)
      else
        raise
      end
    end

Returns a `Digest` subclass by `name` in a thread-safe manner even when on-demand loading is involved.

    require 'digest'

    Digest("MD5")
    # => Digest::MD5

    Digest(:SHA256)
    # => Digest::SHA256

    Digest(:Foo)
    # => LoadError: library not found for class Digest::Foo -- digest/foo

define_singleton_method(symbol, method) → symbol
define_singleton_method(symbol) { block } → symbol
Source

    static VALUE
    rb_obj_define_method(int argc, VALUE *argv, VALUE obj)
    {
        VALUE klass = rb_singleton_class(obj);
        const rb_scope_visibility_t scope_visi = {METHOD_VISI_PUBLIC, FALSE};

        return rb_mod_define_method_with_visibility(argc, argv, klass, &scope_visi);
    }

Defines a public 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. If a block or a method has parameters, they’re used as method parameters.

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

    chris = "Chris"
    chris.define_singleton_method(:greet) {|greeting| "#{greeting}, I'm Chris!" }
    chris.greet("Hi") #=> "Hi, I'm Chris!"

display(port = $>) → nil
Source

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

        out = (!rb_check_arity(argc, 0, 1) ? rb_ractor_stdout() : argv[0]);
        rb_io_write(out, self);

        return Qnil;
    }

Writes `self` on the given port:

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

Output:

    1cat[4, 5, 6]

dup → an_object
Source

    VALUE
    rb_obj_dup(VALUE obj)
    {
        VALUE dup;

        if (special_object_p(obj)) {
            return obj;
        }
        dup = rb_obj_alloc(rb_obj_class(obj));
        return rb_obj_dup_setup(obj, dup);
    }

Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference.

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

### on dup vs 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.

When using `dup`, any modules that the object has been extended with will not be copied.

    class Klass
      attr_accessor :str
    end

    module Foo
      def foo; 'foo'; end
    end

    s1 = Klass.new #=> #<Klass:0x401b3a38>
    s1.extend(Foo) #=> #<Klass:0x401b3a38>
    s1.foo #=> "foo"

    s2 = s1.clone #=> #<Klass:0x401be280>
    s2.foo #=> "foo"

    s3 = s1.dup #=> #<Klass:0x401c1084>
    s3.foo #=> NoMethodError: undefined method `foo' for #<Klass:0x401c1084>

enum_for(method = :each, *args) → enum
enum_for(method = :each, *args){|*args| block} → enum

Creates a new `Enumerator` which will enumerate by calling `method` on `obj`, passing `args` if any. What was yielded by method becomes values of enumerator.

If a block is given, it will be used to calculate the size of the enumerator without the need to iterate it (see `Enumerator#size`).

### Examples

    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)

    # String#split in block form is more memory-effective:
    very_large_string.split("|") { |chunk| return chunk if chunk.include?('DATE') }
    # This could be rewritten more idiomatically with to_enum:
    very_large_string.to_enum(:split, "|").lazy.grep(/DATE/).first

It is typical to call `to_enum` when defining methods for a generic `Enumerable`, in case no block is passed.

Here is such an example, with parameter passing and a sizing block:

    module Enumerable
      # a generic method to repeat the values of any enumerable
      def repeat(n)
        raise ArgumentError, "#{n} is negative!" if n < 0
        unless block_given?
          return to_enum(__method__, n) do # __method__ is :repeat here
            sz = size     # Call size and multiply by n...
            sz * n if sz  # but return nil if size itself is nil
          end
        end
        each do |*val|
          n.times { yield *val }
        end
      end
    end

    %i[hello world].repeat(2) { |w| puts w }
      # => Prints 'hello', 'hello', 'world', 'world'
    enum = (1..14).repeat(3)
      # => returns an Enumerator when called without a block
    enum.first(4) # => [1, 1, 1, 2]
    enum.size # => 42

Alias for: to_enum
obj == other → true or false
equal?(other) → true or false
eql?(other) → true or false
Source

    VALUE
    rb_obj_equal(VALUE obj1, VALUE obj2)
    {
        return RBOOL(obj1 == obj2);
    }

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 as it is used to determine object identity (that is, `a.equal?(b)` if and only if `a` is the same object as `b`):

    obj = "a"
    other = obj.dup

    obj == other      #=> true
    obj.equal? other  #=> false
    obj.equal? obj    #=> true

The `eql?` method returns `true` if `obj` and `other` refer to the same hash key. This is used by `Hash` to test members for equality. For any pair of objects where `eql?` returns `true`, the `hash` value of both objects must be equal. So any subclass that overrides `eql?` should also override `hash` appropriately.

For objects of class `Object`, `eql?` is synonymous with `==`. Subclasses normally continue this tradition by aliasing `eql?` to their overridden `==` method, 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

extend(module, ...) → obj
Source

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

        CONST_ID(id_extend_object, "extend_object");
        CONST_ID(id_extended, "extended");

        rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
        for (i = 0; i < argc; i++) {
            Check_Type(argv[i], T_MODULE);
            if (FL_TEST(argv[i], RMODULE_IS_REFINEMENT)) {
                rb_raise(rb_eTypeError, "Cannot extend object with refinement");
            }
        }
        while (argc--) {
            rb_funcall(argv[argc], id_extend_object, 1, obj);
            rb_funcall(argv[argc], id_extended, 1, obj);
        }
        return obj;
    }

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"

freeze → obj
Source

    VALUE
    rb_obj_freeze(VALUE obj)
    {
        if (!OBJ_FROZEN(obj)) {
            OBJ_FREEZE(obj);
            if (SPECIAL_CONST_P(obj)) {
                rb_bug("special consts should be frozen.");
            }
        }
        return obj;
    }

Prevents further modifications to obj. A `FrozenError` 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 (FrozenError)
     from prog.rb:3

Objects of the following classes are always frozen: `Integer`, `Float`, `Symbol`.

hash → integer
Source

    VALUE
    rb_obj_hash(VALUE obj)
    {
        long hnum = any_hash(obj, objid_hash);
        return ST2FIX(hnum);
    }

Returns the integer hash value for `self`; has the property that if `foo.eql?(bar)` then `foo.hash == bar.hash`.

Class `Hash` uses both `hash` and `eql?` to determine whether two objects used as hash keys are to be treated as the same key. A hash value that exceeds the capacity of an `Integer` is truncated before being used.

Many core classes override method `Object#hash`; other core classes (e.g., `Integer`) calculate the hash internally, and do not call the `hash` method when used as a hash key.

When implementing `hash` for a user-defined class, best practice is to use `Array#hash` with the class name and the values that are important in the instance; this takes advantage of that method’s logic for safely and efficiently generating a hash value:

    def hash
      [self.class, a, b, c].hash
    end

The hash value may differ among invocations or implementations of Ruby. If you need stable hash-like identifiers across Ruby invocations and implementations, use a custom method to generate them.

inspect → string
Source

    static VALUE
    rb_obj_inspect(VALUE obj)
    {
        VALUE ivars = rb_check_funcall(obj, id_instance_variables_to_inspect, 0, 0);
        st_index_t n = 0;
        if (UNDEF_P(ivars) || NIL_P(ivars)) {
            n = rb_ivar_count(obj);
            ivars = Qnil;
        }
        else if (RB_TYPE_P(ivars, T_ARRAY)) {
            n = RARRAY_LEN(ivars);
        }
        else {
            rb_raise(
                rb_eTypeError,
                "Expected #instance_variables_to_inspect to return an Array or nil, but it returned %"PRIsVALUE,
                rb_obj_class(ivars)
            );
        }

        if (n > 0) {
            VALUE c = rb_class_name(CLASS_OF(obj));
            VALUE args[2] = {
                rb_sprintf("-<%"PRIsVALUE":%p", c, (void*)obj),
                ivars
            };
            return rb_exec_recursive(inspect_obj, obj, (VALUE)args);
        }
        else {
            return rb_any_to_s(obj);
        }
    }

Returns a string containing a human-readable representation of obj. The default `inspect` shows the object’s class name, an encoding of its memory address, and a list of the instance variables and their values (by calling `inspect` on each of them). User defined classes should override this method to provide a better representation of obj. When overriding this method, it should return a string whose encoding is compatible with the default external encoding.

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

    class Foo
    end
    Foo.new.inspect                  #=> "#<Foo:0x0300c868>"

    class Bar
      def initialize
        @bar = 1
      end
    end
    Bar.new.inspect                  #=> "#<Bar:0x0300c868 @bar=1>"

If obj responds to `instance_variables_to_inspect`, then only the instance variables listed in the returned array will be included in the inspect string.

    class DatabaseConfig
      def initialize(host, user, password)
        @host = host
        @user = user
        @password = password
      end

    private
      def instance_variables_to_inspect = [:@host, :@user]
    end

    conf = DatabaseConfig.new("localhost", "root", "hunter2")
    conf.inspect #=> #<DatabaseConfig:0x0000000104def350 @host="localhost", @user="root">

instance_of?(class) → true or false
Source

    VALUE
    rb_obj_is_instance_of(VALUE obj, VALUE c)
    {
        c = class_or_module_required(c);
        return RBOOL(rb_obj_class(obj) == c);
    }

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

instance_variable_defined?(symbol) → true or false
instance_variable_defined?(string) → true or false
Source

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

        if (!id) {
            return Qfalse;
        }
        return rb_ivar_defined(obj, id);
    }

Returns `true` if the given instance variable is defined in obj. `String` arguments are converted to symbols.

    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

instance_variable_get(symbol) → obj
instance_variable_get(string) → obj
Source

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

        if (!id) {
            return Qnil;
        }
        return rb_ivar_get(obj, id);
    }

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. `String` arguments are converted to symbols.

    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

instance_variable_set(symbol, obj) → obj
instance_variable_set(string, obj) → obj
Source

    static VALUE
    rb_obj_ivar_set_m(VALUE obj, VALUE iv, VALUE val)
    {
        ID id = id_for_var(obj, iv, instance);
        if (!id) id = rb_intern_str(iv);
        return rb_ivar_set(obj, id, val);
    }

Sets the instance variable named by symbol to the given object. This may circumvent the encapsulation intended by the author of the class, so it should be used with care. The variable does not have to exist prior to this call. If the instance variable name is passed as a string, that string is converted to a symbol.

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

instance_variables → array
Source

    VALUE
    rb_obj_instance_variables(VALUE obj)
    {
        VALUE ary;

        ary = rb_ary_new();
        rb_ivar_foreach(obj, ivar_i, ary);
        return ary;
    }

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]

is_a?(class) → true or false

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

Alias for: kind_of?
itself → obj
Source

    static VALUE
    rb_obj_itself(VALUE obj)
    {
        return obj;
    }

Returns the receiver.

    string = "my string"
    string.itself.object_id == string.object_id   #=> true

kind_of?(class) → true or false
Source

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

        RUBY_ASSERT(RB_TYPE_P(cl, T_CLASS));

        // Fastest path: If the object's class is an exact match we know `c` is a
        // class without checking type and can return immediately.
        if (cl == c) return Qtrue;

        // Note: YJIT needs this function to never allocate and never raise when
        // `c` is a class or a module.

        if (LIKELY(RB_TYPE_P(c, T_CLASS))) {
            // Fast path: Both are T_CLASS
            return class_search_class_ancestor(cl, c);
        }
        else if (RB_TYPE_P(c, T_ICLASS)) {
            // First check if we inherit the includer
            // If we do we can return true immediately
            VALUE includer = RCLASS_INCLUDER(c);
            if (cl == includer) return Qtrue;

            // Usually includer is a T_CLASS here, except when including into an
            // already included Module.
            // If it is a class, attempt the fast class-to-class check and return
            // true if there is a match.
            if (RB_TYPE_P(includer, T_CLASS) && class_search_class_ancestor(cl, includer))
                return Qtrue;

            // We don't include the ICLASS directly, so must check if we inherit
            // the module via another include
            return RBOOL(class_search_ancestor(cl, RCLASS_ORIGIN(c)));
        }
        else if (RB_TYPE_P(c, T_MODULE)) {
            // Slow path: check each ancestor in the linked list and its method table
            return RBOOL(class_search_ancestor(cl, RCLASS_ORIGIN(c)));
        }
        else {
            rb_raise(rb_eTypeError, "class or module required");
            UNREACHABLE_RETURN(Qfalse);
        }
    }

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

Also aliased as: is_a?
method(sym) → method
Source

    VALUE
    rb_obj_method(VALUE obj, VALUE vid)
    {
        return obj_method(obj, vid, FALSE);
    }

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"

Note that `Method` implements `to_proc` method, which means it can be used with iterators.

    [ 1, 2, 3 ].each(&method(:puts)) # => prints 3 lines to stdout

    out = File.open('test.txt', 'w')
    [ 1, 2, 3 ].each(&out.method(:puts)) # => prints 3 lines to file

    require 'date'
    %w[2017-03-01 2017-03-02].collect(&Date.method(:parse))
    #=> [#<Date: 2017-03-01 ((2457814j,0s,0n),+0s,2299161j)>, #<Date: 2017-03-02 ((2457815j,0s,0n),+0s,2299161j)>]

methods(regular=true) → array
Source

    VALUE
    rb_obj_methods(int argc, const VALUE *argv, VALUE obj)
    {
        rb_check_arity(argc, 0, 1);
        if (argc > 0 && !RTEST(argv[0])) {
            return rb_obj_singleton_methods(argc, argv, obj);
        }
        return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_i);
    }

Returns a list of the names of public and protected methods of obj. This will include all the methods accessible in obj’s ancestors. If the optional parameter is `false`, it returns an array of obj’s public and protected singleton methods, the array will not include methods in modules included in obj.

    class Klass
      def klass_method()
      end
    end
    k = Klass.new
    k.methods[0..9]    #=> [:klass_method, :nil?, :===,
                       #    :==~, :!, :eql?
                       #    :hash, :<=>, :class, :singleton_class]
    k.methods.length   #=> 56

    k.methods(false)   #=> []
    def k.singleton_method; end
    k.methods(false)   #=> [:singleton_method]

    module M123; def m123; end end
    k.extend M123
    k.methods(false)   #=> [:singleton_method]

nil? → true or false
Source

    VALUE
    rb_false(VALUE obj)
    {
        return Qfalse;
    }

Only the object nil responds `true` to `nil?`.

    Object.new.nil?   #=> false
    nil.nil?          #=> true

__id__ → integer
object_id → integer
Source

    VALUE
    rb_obj_id(VALUE obj)
    {
        /* If obj is an immediate, the object ID is obj directly converted to a Numeric.
         * Otherwise, the object ID is a Numeric that is a non-zero multiple of
         * (RUBY_IMMEDIATE_MASK + 1) which guarantees that it does not collide with
         * any immediates. */
        return rb_find_object_id(rb_gc_get_objspace(), obj, object_id);
    }

Returns an integer identifier for `obj`.

The same number will be returned on all calls to `object_id` for a given object, and no two active objects will share an id.

Note: that some objects of builtin classes are reused for optimization. This is the case for immediate values and frozen string literals.

`BasicObject` implements `__id__`, `Kernel` implements `object_id`.

Immediate values are not passed by reference but are passed by value: `nil`, `true`, `false`, Fixnums, Symbols, and some Floats.

    Object.new.object_id  == Object.new.object_id  # => false
    (21 * 2).object_id    == (21 * 2).object_id    # => true
    "hello".object_id     == "hello".object_id     # => false
    "hi".freeze.object_id == "hi".freeze.object_id # => true

private_methods(all=true) → array
Source

    VALUE
    rb_obj_private_methods(int argc, const VALUE *argv, VALUE obj)
    {
        return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_priv_i);
    }

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.

protected_methods(all=true) → array
Source

    VALUE
    rb_obj_protected_methods(int argc, const VALUE *argv, VALUE obj)
    {
        return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_prot_i);
    }

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.

public_method(sym) → method
Source

    VALUE
    rb_obj_public_method(VALUE obj, VALUE vid)
    {
        return obj_method(obj, vid, TRUE);
    }

Similar to method, searches public method only.

public_methods(all=true) → array
Source

    VALUE
    rb_obj_public_methods(int argc, const VALUE *argv, VALUE obj)
    {
        return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_pub_i);
    }

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.

public_send(symbol [, args...]) → obj
public_send(string [, args...]) → obj
Source

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

Invokes the method identified by symbol, passing it any arguments specified. Unlike send, `public_send` calls public methods only. When the method is identified by a string, the string is converted to a symbol.

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

remove_instance_variable(symbol) → obj
remove_instance_variable(string) → obj
Source

    VALUE
    rb_obj_remove_instance_variable(VALUE obj, VALUE name)
    {
        const ID id = id_for_var(obj, name, an, instance);

        // Frozen check comes here because it's expected that we raise a
        // NameError (from the id_for_var check) before we raise a FrozenError
        rb_check_frozen(obj);

        if (id) {
            VALUE val = rb_ivar_delete(obj, id, Qundef);

            if (!UNDEF_P(val)) return val;
        }

        rb_name_err_raise("instance variable %1$s not defined",
                          obj, name);
        UNREACHABLE_RETURN(Qnil);
    }

Removes the named instance variable from obj, returning that variable’s value. The name can be passed as a symbol or as a string.

    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

respond_to?(symbol, include_all=false) → true or false
respond_to?(string, include_all=false) → true or false
Source

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

        rb_scan_args(argc, argv, "11", &mid, &priv);
        if (!(id = rb_check_id(&mid))) {
            VALUE ret = basic_obj_respond_to_missing(ec, CLASS_OF(obj), obj,
                                                     rb_to_symbol(mid), priv);
            if (UNDEF_P(ret)) ret = Qfalse;
            return ret;
        }
        return  RBOOL(basic_obj_respond_to(ec, obj, id, !RTEST(priv)));
    }

Returns `true` if obj responds to the given method. Private and protected 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.

When the method name parameter is given as a string, the string is converted to a symbol.

respond_to_missing?(symbol, include_all) → true or false
respond_to_missing?(string, include_all) → true or false
Source

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

DO NOT USE THIS DIRECTLY.

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

When the method name parameter is given as a string, the string is converted to a symbol.

See `respond_to?`, and the example of `BasicObject`.

send(symbol [, args...]) → obj
__send__(symbol [, args...]) → obj
send(string [, args...]) → obj
__send__(string [, args...]) → obj
Source

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

Invokes the method identified by symbol, passing it any arguments specified. When the method is identified by a string, the string is converted to a symbol.

`BasicObject` implements `__send__`, `Kernel` implements `send`. `__send__` is safer than `send` when obj has the same method name like `Socket`. See also `public_send`.

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

singleton_class → class
Source

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

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

If obj is `nil`, `true`, or `false`, it returns `NilClass`, `TrueClass`, or `FalseClass`, respectively. If obj is an `Integer`, a `Float` or a `Symbol`, it raises a `TypeError`.

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

singleton_method(sym) → method
Source

    VALUE
    rb_obj_singleton_method(VALUE obj, VALUE vid)
    {
        VALUE sc = rb_singleton_class_get(obj);
        VALUE klass;
        ID id = rb_check_id(&vid);

        if (NIL_P(sc) ||
            NIL_P(klass = RCLASS_ORIGIN(sc)) ||
            !NIL_P(rb_special_singleton_class(obj))) {
            /* goto undef; */
        }
        else if (! id) {
            VALUE m = mnew_missing_by_name(klass, obj, &vid, FALSE, rb_cMethod);
            if (m) return m;
            /* else goto undef; */
        }
        else {
            VALUE args[2] = {obj, vid};
            VALUE ruby_method = rb_rescue(rb_obj_singleton_method_lookup, (VALUE)args, rb_obj_singleton_method_lookup_fail, Qfalse);
            if (ruby_method) {
                struct METHOD *method = (struct METHOD *)RTYPEDDATA_GET_DATA(ruby_method);
                VALUE lookup_class = RBASIC_CLASS(obj);
                VALUE stop_class = rb_class_superclass(sc);
                VALUE method_class = method->iclass;

                /* Determine if method is in singleton class, or module included in or prepended to it */
                do {
                    if (lookup_class == method_class) {
                        return ruby_method;
                    }
                    lookup_class = RCLASS_SUPER(lookup_class);
                } while (lookup_class && lookup_class != stop_class);
            }
        }

      /* undef: */
        vid = ID2SYM(id);
        rb_name_err_raise("undefined singleton method '%1$s' for '%2$s'",
                          obj, vid);
        UNREACHABLE_RETURN(Qundef);
    }

Similar to method, searches singleton method only.

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

    k = Demo.new(99)
    def k.hi
      "Hi, @iv = #{@iv}"
    end
    m = k.singleton_method(:hi)
    m.call   #=> "Hi, @iv = 99"
    m = k.singleton_method(:hello) #=> NameError

singleton_methods(all=true) → array
Source

    VALUE
    rb_obj_singleton_methods(int argc, const VALUE *argv, VALUE obj)
    {
        VALUE ary, klass, origin;
        struct method_entry_arg me_arg;
        struct rb_id_table *mtbl;
        int recur = TRUE;

        if (rb_check_arity(argc, 0, 1)) recur = RTEST(argv[0]);
        if (RCLASS_SINGLETON_P(obj)) {
            rb_singleton_class(obj);
        }
        klass = CLASS_OF(obj);
        origin = RCLASS_ORIGIN(klass);
        me_arg.list = st_init_numtable();
        me_arg.recur = recur;
        if (klass && RCLASS_SINGLETON_P(klass)) {
            if ((mtbl = RCLASS_M_TBL(origin)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg);
            klass = RCLASS_SUPER(klass);
        }
        if (recur) {
            while (klass && (RCLASS_SINGLETON_P(klass) || RB_TYPE_P(klass, T_ICLASS))) {
                if (klass != origin && (mtbl = RCLASS_M_TBL(klass)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg);
                klass = RCLASS_SUPER(klass);
            }
        }
        ary = rb_ary_new2(me_arg.list->num_entries);
        st_foreach(me_arg.list, ins_methods_i, ary);
        st_free_table(me_arg.list);

        return ary;
    }

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]

to_enum(method = :each, *args) → enum
to_enum(method = :each, *args) {|*args| block} → enum
Source

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

        if (argc > 0) {
            --argc;
            meth = *argv++;
        }
        enumerator = rb_enumeratorize_with_size(obj, meth, argc, argv, 0);
        if (rb_block_given_p()) {
            RB_OBJ_WRITE(enumerator, &enumerator_ptr(enumerator)->size, rb_block_proc());
        }
        return enumerator;
    }

Creates a new `Enumerator` which will enumerate by calling `method` on `obj`, passing `args` if any. What was yielded by method becomes values of enumerator.

If a block is given, it will be used to calculate the size of the enumerator without the need to iterate it (see `Enumerator#size`).

### Examples

    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)

    # String#split in block form is more memory-effective:
    very_large_string.split("|") { |chunk| return chunk if chunk.include?('DATE') }
    # This could be rewritten more idiomatically with to_enum:
    very_large_string.to_enum(:split, "|").lazy.grep(/DATE/).first

It is typical to call `to_enum` when defining methods for a generic `Enumerable`, in case no block is passed.

Here is such an example, with parameter passing and a sizing block:

    module Enumerable
      # a generic method to repeat the values of any enumerable
      def repeat(n)
        raise ArgumentError, "#{n} is negative!" if n < 0
        unless block_given?
          return to_enum(__method__, n) do # __method__ is :repeat here
            sz = size     # Call size and multiply by n...
            sz * n if sz  # but return nil if size itself is nil
          end
        end
        each do |*val|
          n.times { yield *val }
        end
      end
    end

    %i[hello world].repeat(2) { |w| puts w }
      # => Prints 'hello', 'hello', 'world', 'world'
    enum = (1..14).repeat(3)
      # => returns an Enumerator when called without a block
    enum.first(4) # => [1, 1, 1, 2]
    enum.size # => 42

Also aliased as: enum_for
to_s → string
Source

    VALUE
    rb_any_to_s(VALUE obj)
    {
        VALUE str;
        VALUE cname = rb_class_name(CLASS_OF(obj));

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

        return str;
    }

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

to_yaml(options = {})
Source

    # File ext/psych/lib/psych/core_ext.rb, line 12
    def to_yaml options = {}
      Psych.dump self, options
    end

Convert an object to `YAML`. See `Psych.dump` for more information on the available `options`.