Class: Object
Overview
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
).
Constant Summary collapse
- Bignum =
An obsolete class, use Integer
rb_cInteger
- Fixnum =
An obsolete class, use Integer
rb_cInteger
Instance Method Summary collapse
-
#!~(other) ⇒ Boolean
Returns true if two objects do not match (using the =~ method), otherwise false.
-
#<=>(other) ⇒ 0?
Returns 0 if
obj
andother
are the same object orobj == other
, otherwise nil. -
#===(other) ⇒ Boolean
Case Equality – For class Object, effectively the same as calling
#==
, but typically overridden by descendants to provide meaningful semantics incase
statements. -
#=~(other) ⇒ nil
This method is deprecated.
-
#class ⇒ Class
Returns the class of obj.
-
#clone(freeze: true) ⇒ Object
Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference.
-
#define_singleton_method(*args) ⇒ Object
Defines a singleton method in the receiver.
-
#display(port = $>) ⇒ nil
Prints obj on the given port (default
$>
). -
#dup ⇒ Object
Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference.
-
#enum_for(*args) ⇒ Object
Creates a new Enumerator which will enumerate by calling
method
onobj
, passingargs
if any. -
#eql?(obj2) ⇒ Object
Equality — At the Object level, #== returns
true
only ifobj
andother
are the same object. -
#extend ⇒ Object
Adds to obj the instance methods from each module given as a parameter.
-
#freeze ⇒ Object
Prevents further modifications to obj.
-
#frozen? ⇒ Boolean
Returns the freeze status of obj.
- #hash ⇒ Object
-
#initialize_clone(orig) ⇒ Object
! :nodoc:.
-
#initialize_copy(orig) ⇒ Object
:nodoc:.
-
#initialize_dup(orig) ⇒ Object
! :nodoc:.
-
#inspect ⇒ String
Returns a string containing a human-readable representation of obj.
-
#instance_of? ⇒ Boolean
Returns
true
if obj is an instance of the given class. -
#instance_variable_defined?(iv) ⇒ Object
Returns
true
if the given instance variable is defined in obj. -
#instance_variable_get(iv) ⇒ Object
Returns the value of the given instance variable, or nil if the instance variable is not set.
-
#instance_variable_set(iv, val) ⇒ Object
Sets the instance variable named by symbol to the given object, thereby frustrating the efforts of the class’s author to attempt to provide proper encapsulation.
-
#instance_variables ⇒ Array
Returns an array of instance variable names for the receiver.
-
#is_a?(c) ⇒ Object
Returns
true
if class is the class of obj, or if class is one of the superclasses of obj or modules included in obj. -
#itself ⇒ Object
Returns the receiver.
-
#kind_of?(c) ⇒ Object
Returns
true
if class is the class of obj, or if class is one of the superclasses of obj or modules included in obj. -
#method(sym) ⇒ Object
Looks up the named method as a receiver in obj, returning a Method object (or raising NameError).
-
#methods(regular = true) ⇒ Array
Returns a list of the names of public and protected methods of obj.
-
#nil? ⇒ Boolean
Only the object nil responds
true
tonil?
. -
#object_id ⇒ Object
call-seq: obj.__id__ -> integer obj.object_id -> integer.
-
#private_methods(all = true) ⇒ Array
Returns the list of private methods accessible to obj.
-
#protected_methods(all = true) ⇒ Array
Returns the list of protected methods accessible to obj.
-
#public_method(sym) ⇒ Object
Similar to method, searches public method only.
-
#public_methods(all = true) ⇒ Array
Returns the list of public methods accessible to obj.
-
#public_send(*args) ⇒ Object
Invokes the method identified by symbol, passing it any arguments specified.
-
#remove_instance_variable(name) ⇒ Object
Removes the named instance variable from obj, returning that variable’s value.
-
#respond_to?(*args) ⇒ Object
Returns
true
if obj responds to the given method. -
#respond_to_missing?(mid, priv) ⇒ Object
DO NOT USE THIS DIRECTLY.
-
#send(*args) ⇒ Object
Invokes the method identified by symbol, passing it any arguments specified.
-
#singleton_class ⇒ Class
Returns the singleton class of obj.
-
#singleton_method(sym) ⇒ Object
Similar to method, searches singleton method only.
-
#singleton_methods(all = true) ⇒ Array
Returns an array of the names of singleton methods for obj.
-
#taint ⇒ Object
Returns object.
-
#tainted? ⇒ false
Returns false.
-
#tap {|x| ... } ⇒ Object
Yields self to the block, and then returns self.
-
#then ⇒ Object
Yields self to the block and returns the result of the block.
-
#to_enum(*args) ⇒ Object
Creates a new Enumerator which will enumerate by calling
method
onobj
, passingargs
if any. -
#to_s ⇒ String
Returns a string representing obj.
-
#trust ⇒ Object
Returns object.
-
#untaint ⇒ Object
Returns object.
-
#untrust ⇒ Object
Returns object.
-
#untrusted? ⇒ false
Returns false.
-
#yield_self ⇒ Object
Yields self to the block and returns the result of the block.
Methods included from Kernel
#Array, #Complex, #Float, #Hash, #Integer, #Rational, #String, #__callee__, #__dir__, #__method__, #`, #abort, #at_exit, #autoload, #autoload?, #binding, #block_given?, #callcc, #caller, #caller_locations, #catch, #eval, #exec, #exit, #exit!, #fail, #fork, #format, #gets, #global_variables, #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, #syscall, #system, #test, #throw, #trace_var, #trap, #untrace_var
Instance Method Details
#!~(other) ⇒ Boolean
Returns true if two objects do not match (using the =~ method), otherwise false.
1642 1643 1644 1645 1646 1647 |
# File 'object.c', line 1642 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
and other
are the same object or obj == other
, otherwise nil.
The #<=> is used by various methods to compare objects, for example Enumerable#sort, Enumerable#max etc.
Your implementation of #<=> should return one of the following values: -1, 0, 1 or nil. -1 means self is smaller than other. 0 means self is equal to other. 1 means self is bigger than other. Nil means the two values could not be compared.
When you define #<=>, you can include Comparable to gain the methods #<=, #<, #==, #>=, #> and #between?.
1668 1669 1670 1671 1672 1673 1674 |
# File 'object.c', line 1668 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.
131 132 133 134 135 136 137 138 139 140 141 142 143 |
# File 'object.c', line 131 VALUE rb_equal(VALUE obj1, VALUE obj2) { VALUE result; if (obj1 == obj2) return Qtrue; result = rb_equal_opt(obj1, obj2); if (result == Qundef) { result = rb_funcall(obj1, id_eq, 1, obj2); } if (RTEST(result)) return Qtrue; return Qfalse; } |
#=~(other) ⇒ nil
This method is deprecated.
This is not only unuseful but also troublesome because it may hide a type error.
1624 1625 1626 1627 1628 1629 1630 1631 1632 |
# File 'object.c', line 1624 static VALUE rb_obj_match(VALUE obj1, VALUE obj2) { if (rb_warning_category_enabled_p(RB_WARN_CATEGORY_DEPRECATED)) { rb_warn("deprecated Object#=~ is called on %"PRIsVALUE "; it always returns nil", rb_obj_class(obj1)); } return Qnil; } |
#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 #=> Integer
self.class #=> Object
285 286 287 288 289 |
# File 'object.c', line 285 VALUE rb_obj_class(VALUE obj) { return rb_class_real(CLASS_OF(obj)); } |
#clone(freeze: true) ⇒ Object
Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference. #clone copies the frozen (unless :freeze
keyword argument is given with a false value) 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.
404 405 406 407 408 409 410 411 |
# File 'object.c', line 404 static VALUE rb_obj_clone2(int argc, VALUE *argv, VALUE obj) { int kwfreeze = freeze_opt(argc, argv); if (!special_object_p(obj)) return mutable_obj_clone(obj, kwfreeze); return immutable_obj_clone(obj, kwfreeze); } |
#define_singleton_method(symbol, method) ⇒ Object #define_singleton_method(symbol) { ... } ⇒ Object
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. 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!"
2151 2152 2153 2154 2155 2156 2157 |
# File 'proc.c', line 2151 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
nil
end
For example:
1.display
"cat".display
[ 4, 5, 6 ].display
puts
produces:
1cat[4, 5, 6]
7893 7894 7895 7896 7897 7898 7899 7900 7901 7902 |
# File 'io.c', line 7893 static VALUE rb_obj_display(int argc, VALUE *argv, VALUE self) { VALUE out; out = (!rb_check_arity(argc, 0, 1) ? rb_stdout : argv[0]); rb_io_write(out, self); return Qnil; } |
#dup ⇒ Object
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:0x401b3a38> s2.foo #=> “foo”
s3 = s1.dup #=> #<Klass:0x401b3a38> s3.foo #=> NoMethodError: undefined method ‘foo’ for #<Klass:0x401b3a38>
530 531 532 533 534 535 536 537 538 539 540 541 542 543 |
# File 'object.c', line 530 VALUE rb_obj_dup(VALUE obj) { VALUE dup; if (special_object_p(obj)) { return obj; } dup = rb_obj_alloc(rb_obj_class(obj)); init_copy(dup, obj); rb_funcall(dup, id_init_dup, 1, obj); return dup; } |
#to_enum(method = :each, *args) ⇒ Enumerator #enum_for(method = :each, *args) ⇒ Enumerator #to_enum(method = :each, *args) {|*args| ... } ⇒ Enumerator #enum_for(method = :each, *args) {|*args| ... } ⇒ 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
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 |
# File 'enumerator.c', line 351 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()) { enumerator_ptr(enumerator)->size = rb_block_proc(); } return enumerator; } |
#==(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 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
209 210 211 212 213 214 |
# File 'object.c', line 209 MJIT_FUNC_EXPORTED 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"
1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 |
# File 'eval.c', line 1764 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); while (argc--) { rb_funcall(argv[argc], id_extend_object, 1, obj); rb_funcall(argv[argc], id_extended, 1, obj); } return obj; } |
#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 (FrozenError)
from prog.rb:3
Objects of the following classes are always frozen: Integer, Float, Symbol.
1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 |
# File 'object.c', line 1286 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; } |
#frozen? ⇒ Boolean
Returns the freeze status of obj.
a = [ "a", "b", "c" ]
a.freeze #=> ["a", "b", "c"]
a.frozen? #=> true
1315 1316 1317 1318 1319 |
# File 'object.c', line 1315 VALUE rb_obj_frozen_p(VALUE obj) { return OBJ_FROZEN(obj) ? Qtrue : Qfalse; } |
#hash ⇒ Object
216 |
# File 'object.c', line 216 VALUE rb_obj_hash(VALUE obj); |
#initialize_clone(orig) ⇒ Object
!
:nodoc:
633 634 635 636 637 638 |
# File 'object.c', line 633 VALUE rb_obj_init_dup_clone(VALUE obj, VALUE orig) { rb_funcall(obj, id_init_copy, 1, orig); return obj; } |
#initialize_copy(orig) ⇒ Object
:nodoc:
613 614 615 616 617 618 619 620 621 622 |
# File 'object.c', line 613 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"); } return obj; } |
#initialize_dup(orig) ⇒ Object
!
:nodoc:
633 634 635 636 637 638 |
# File 'object.c', line 633 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. The default #inspect shows the object’s class name, an encoding of the object id, 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
= 1
end
end
Bar.new.inspect #=> "#<Bar:0x0300c868 @bar=1>"
759 760 761 762 763 764 765 766 767 768 769 770 771 772 |
# File 'object.c', line 759 static VALUE rb_obj_inspect(VALUE obj) { if (rb_ivar_count(obj) > 0) { VALUE str; VALUE c = rb_class_name(CLASS_OF(obj)); str = rb_sprintf("-<%"PRIsVALUE":%p", c, (void*)obj); return rb_exec_recursive(inspect_obj, obj, str); } else { return rb_any_to_s(obj); } } |
#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
817 818 819 820 821 822 823 |
# File 'object.c', line 817 VALUE rb_obj_is_instance_of(VALUE obj, VALUE c) { c = class_or_module_required(c); if (rb_obj_class(obj) == c) return Qtrue; return Qfalse; } |
#instance_variable_defined?(symbol) ⇒ Boolean #instance_variable_defined?(string) ⇒ Boolean
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
2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 |
# File 'object.c', line 2941 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); } |
#instance_variable_get(symbol) ⇒ Object #instance_variable_get(string) ⇒ 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. 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
2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 |
# File 'object.c', line 2879 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); } |
#instance_variable_set(symbol, obj) ⇒ Object #instance_variable_set(string, obj) ⇒ Object
Sets the instance variable named by symbol to the given object, thereby frustrating the efforts of the class’s author to attempt to provide proper encapsulation. 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\">"
2913 2914 2915 2916 2917 2918 2919 |
# File 'object.c', line 2913 static VALUE rb_obj_ivar_set(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); } |
#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]
1578 1579 1580 1581 1582 1583 1584 1585 1586 |
# File 'variable.c', line 1578 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
861 862 863 864 865 866 867 868 |
# File 'object.c', line 861 VALUE rb_obj_is_kind_of(VALUE obj, VALUE c) { VALUE cl = CLASS_OF(obj); c = class_or_module_required(c); return class_search_ancestor(cl, RCLASS_ORIGIN(c)) ? Qtrue : Qfalse; } |
#itself ⇒ Object
Returns the receiver.
string = "my string"
string.itself.object_id == string.object_id #=> true
556 557 558 559 560 |
# File 'object.c', line 556 static VALUE rb_obj_itself(VALUE obj) { return obj; } |
#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
861 862 863 864 865 866 867 868 |
# File 'object.c', line 861 VALUE rb_obj_is_kind_of(VALUE obj, VALUE c) { VALUE cl = CLASS_OF(obj); c = class_or_module_required(c); return class_search_ancestor(cl, RCLASS_ORIGIN(c)) ? Qtrue : Qfalse; } |
#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"
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)>]
1860 1861 1862 1863 1864 |
# File 'proc.c', line 1860 VALUE rb_obj_method(VALUE obj, VALUE vid) { return obj_method(obj, vid, FALSE); } |
#methods(regular = true) ⇒ Array
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]
1360 1361 1362 1363 1364 1365 1366 1367 1368 |
# File 'class.c', line 1360 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); } |
#nil? ⇒ Boolean
Only the object nil responds true
to nil?
.
Object.new.nil? #=> false
nil.nil? #=> true
1607 1608 1609 1610 1611 |
# File 'object.c', line 1607 MJIT_FUNC_EXPORTED VALUE rb_false(VALUE obj) { return Qfalse; } |
#object_id ⇒ Object
call-seq:
obj.__id__ -> integer
obj.object_id -> integer
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
3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 |
# File 'gc.c', line 3769 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 */ return rb_find_object_id(obj, cached_object_id); } |
#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.
1394 1395 1396 1397 1398 |
# File 'class.c', line 1394 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); } |
#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.
1379 1380 1381 1382 1383 |
# File 'class.c', line 1379 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); } |
#public_method(sym) ⇒ Object
Similar to method, searches public method only.
1873 1874 1875 1876 1877 |
# File 'proc.c', line 1873 VALUE rb_obj_public_method(VALUE obj, VALUE vid) { return obj_method(obj, vid, TRUE); } |
#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.
1409 1410 1411 1412 1413 |
# File 'class.c', line 1409 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); } |
#public_send(symbol[, args...]) ⇒ Object #public_send(string[, args...]) ⇒ Object
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
1207 1208 1209 1210 1211 |
# File 'vm_eval.c', line 1207 static VALUE rb_f_public_send(int argc, VALUE *argv, VALUE recv) { return send_internal_kw(argc, argv, recv, CALL_PUBLIC); } |
#remove_instance_variable(symbol) ⇒ Object #remove_instance_variable(string) ⇒ Object
Removes the named instance variable from obj, returning that variable’s value. String arguments are converted to symbols.
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
1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 |
# File 'variable.c', line 1633 VALUE rb_obj_remove_instance_variable(VALUE obj, VALUE name) { VALUE val = Qnil; const ID id = id_for_var(obj, name, an, instance); st_data_t n, v; struct st_table *iv_index_tbl; st_data_t index; rb_check_frozen(obj); if (!id) { goto not_defined; } switch (BUILTIN_TYPE(obj)) { case T_OBJECT: iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj); if (!iv_index_tbl) break; if (!st_lookup(iv_index_tbl, (st_data_t)id, &index)) break; if (ROBJECT_NUMIV(obj) <= index) break; val = ROBJECT_IVPTR(obj)[index]; if (val != Qundef) { ROBJECT_IVPTR(obj)[index] = Qundef; return val; } break; case T_CLASS: case T_MODULE: n = id; if (RCLASS_IV_TBL(obj) && st_delete(RCLASS_IV_TBL(obj), &n, &v)) { return (VALUE)v; } break; default: if (FL_TEST(obj, FL_EXIVAR)) { if (generic_ivar_remove(obj, id, &val)) { return val; } } break; } not_defined: rb_name_err_raise("instance variable %1$s not defined", obj, name); UNREACHABLE_RETURN(Qnil); } |
#respond_to?(symbol, include_all = false) ⇒ Boolean #respond_to?(string, include_all = false) ⇒ Boolean
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.
2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 |
# File 'vm_method.c', line 2216 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 (ret == Qundef) ret = Qfalse; return ret; } if (basic_obj_respond_to(ec, obj, id, !RTEST(priv))) return Qtrue; return Qfalse; } |
#respond_to_missing?(symbol, include_all) ⇒ Boolean #respond_to_missing?(string, include_all) ⇒ Boolean
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.
2250 2251 2252 2253 2254 |
# File 'vm_method.c', line 2250 static VALUE obj_respond_to_missing(VALUE obj, VALUE mid, VALUE priv) { return Qfalse; } |
#send(symbol[, args...]) ⇒ Object #__send__(symbol[, args...]) ⇒ Object #send(string[, args...]) ⇒ Object #__send__(string[, args...]) ⇒ Object
Invokes the method identified by symbol, passing it any
arguments specified. You can use <code>__send__</code> if the name
+send+ clashes with an existing method in _obj_.
When the method is identified by a string, the string is converted
to a symbol.
BasicObject implements +__send__+, Kernel implements +send+.
class Klass
def hello(*args)
"Hello " + args.join(' ')
end
end
k = Klass.new
k.send :hello, "gentle", "readers" #=> "Hello gentle readers"
1187 1188 1189 1190 1191 |
# File 'vm_eval.c', line 1187 VALUE rb_f_send(int argc, VALUE *argv, VALUE recv) { return send_internal_kw(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 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
308 309 310 311 312 |
# File 'object.c', line 308 static VALUE rb_obj_singleton_class(VALUE obj) { return rb_singleton_class(obj); } |
#singleton_method(sym) ⇒ Object
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
1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 |
# File 'proc.c', line 1903 VALUE rb_obj_singleton_method(VALUE obj, VALUE vid) { const rb_method_entry_t *me; VALUE klass = rb_singleton_class_get(obj); ID id = rb_check_id(&vid); if (NIL_P(klass) || NIL_P(klass = RCLASS_ORIGIN(klass))) { undef: rb_name_err_raise("undefined singleton method `%1$s' for `%2$s'", obj, vid); } if (!id) { VALUE m = mnew_missing_by_name(klass, obj, &vid, FALSE, rb_cMethod); if (m) return m; goto undef; } me = rb_method_entry_at(klass, id); if (UNDEFINED_METHOD_ENTRY_P(me) || UNDEFINED_REFINED_METHOD_P(me->def)) { vid = ID2SYM(id); goto undef; } return mnew_from_me(me, klass, klass, obj, id, rb_cMethod, FALSE); } |
#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]
1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 |
# File 'class.c', line 1448 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 (RB_TYPE_P(obj, T_CLASS) && FL_TEST(obj, FL_SINGLETON)) { rb_singleton_class(obj); } klass = CLASS_OF(obj); origin = RCLASS_ORIGIN(klass); me_arg.list = st_init_numtable(); me_arg.recur = recur; if (klass && FL_TEST(klass, FL_SINGLETON)) { 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 && (FL_TEST(klass, FL_SINGLETON) || 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; } |
#taint ⇒ Object
Returns object. This method is deprecated and will be removed in Ruby 3.2.
1182 1183 1184 1185 1186 1187 |
# File 'object.c', line 1182 VALUE rb_obj_taint(VALUE obj) { rb_warning("Object#taint is deprecated and will be removed in Ruby 3.2."); return obj; } |
#tainted? ⇒ false
Returns false. This method is deprecated and will be removed in Ruby 3.2.
1168 1169 1170 1171 1172 1173 |
# File 'object.c', line 1168 VALUE rb_obj_tainted(VALUE obj) { rb_warning("Object#tainted? is deprecated and will be removed in Ruby 3.2."); return Qfalse; } |
#tap {|x| ... } ⇒ Object
Yields self to the block, and then returns self. 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}" }
.to_a .tap {|x| puts "array: #{x}" }
.select {|x| x.even? } .tap {|x| puts "evens: #{x}" }
.map {|x| x*x } .tap {|x| puts "squares: #{x}" }
908 909 910 911 912 913 |
# File 'object.c', line 908 VALUE rb_obj_tap(VALUE obj) { rb_yield(obj); return obj; } |
#then {|x| ... } ⇒ Object #yield_self {|x| ... } ⇒ Object
Yields self to the block and returns the result of the block.
3.next.then {|x| x**x }.to_s #=> "256"
"my string".yield_self {|s| s.upcase } #=> "MY STRING"
Good usage for then
is value piping in method chains:
require 'open-uri'
require 'json'
construct_url(arguments).
then {|url| open(url).read }.
then {|response| JSON.parse(response) }
When called without block, the method returns Enumerator
, which can be used, for example, for conditional circuit-breaking:
# meets condition, no-op
1.then.detect(&:odd?) # => 1
# does not meet condition, drop value
2.then.detect(&:odd?) # => nil
598 599 600 601 602 603 |
# File 'object.c', line 598 static VALUE rb_obj_yield_self(VALUE obj) { RETURN_SIZED_ENUMERATOR(obj, 0, 0, rb_obj_size); return rb_yield_values2(1, &obj); } |
#to_enum(method = :each, *args) ⇒ Enumerator #enum_for(method = :each, *args) ⇒ Enumerator #to_enum(method = :each, *args) {|*args| ... } ⇒ Enumerator #enum_for(method = :each, *args) {|*args| ... } ⇒ 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
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 |
# File 'enumerator.c', line 351 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()) { enumerator_ptr(enumerator)->size = rb_block_proc(); } return enumerator; } |
#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”.
653 654 655 656 657 658 659 660 661 662 |
# File 'object.c', line 653 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; } |
#trust ⇒ Object
Returns object. This method is deprecated and will be removed in Ruby 3.2.
1240 1241 1242 1243 1244 1245 |
# File 'object.c', line 1240 VALUE rb_obj_trust(VALUE obj) { rb_warning("Object#trust is deprecated and will be removed in Ruby 3.2."); return obj; } |
#untaint ⇒ Object
Returns object. This method is deprecated and will be removed in Ruby 3.2.
1197 1198 1199 1200 1201 1202 |
# File 'object.c', line 1197 VALUE rb_obj_untaint(VALUE obj) { rb_warning("Object#untaint is deprecated and will be removed in Ruby 3.2."); return obj; } |
#untrust ⇒ Object
Returns object. This method is deprecated and will be removed in Ruby 3.2.
1225 1226 1227 1228 1229 1230 |
# File 'object.c', line 1225 VALUE rb_obj_untrust(VALUE obj) { rb_warning("Object#untrust is deprecated and will be removed in Ruby 3.2."); return obj; } |
#untrusted? ⇒ false
Returns false. This method is deprecated and will be removed in Ruby 3.2.
1211 1212 1213 1214 1215 1216 |
# File 'object.c', line 1211 VALUE rb_obj_untrusted(VALUE obj) { rb_warning("Object#untrusted? is deprecated and will be removed in Ruby 3.2."); return Qfalse; } |
#then {|x| ... } ⇒ Object #yield_self {|x| ... } ⇒ Object
Yields self to the block and returns the result of the block.
3.next.then {|x| x**x }.to_s #=> "256"
"my string".yield_self {|s| s.upcase } #=> "MY STRING"
Good usage for then
is value piping in method chains:
require 'open-uri'
require 'json'
construct_url(arguments).
then {|url| open(url).read }.
then {|response| JSON.parse(response) }
When called without block, the method returns Enumerator
, which can be used, for example, for conditional circuit-breaking:
# meets condition, no-op
1.then.detect(&:odd?) # => 1
# does not meet condition, drop value
2.then.detect(&:odd?) # => nil
598 599 600 601 602 603 |
# File 'object.c', line 598 static VALUE rb_obj_yield_self(VALUE obj) { RETURN_SIZED_ENUMERATOR(obj, 0, 0, rb_obj_size); return rb_yield_values2(1, &obj); } |