I just started playing with JRuby. This is my first ruby post. I had a hard time understanding classes vs objects in Ruby. It doesnt mean like what classes & objects in other Object oriented laguages. for an example
Class.is_a? Object
returns true
and
Object.is_a? Object
too.
so class & Object are both objects
here comes another one
Class.is_a? Class
returns true
and
Object.is_a? Class
too.
wait, i am not done yet
Object.instance_of? Class
Class.instance_of? Class
Both are true
Object.instance_of? Object
Class.instance_of? Object
Both are false. right, nothing can be instance of object.
And
Class.kind_of? Class
Object.kind_of? Class
both are true
Class.kind_of? Object
Object.kind_of? Object
both are true
So both are exactly same, then why do we have both these.?
After some more digging, i wrote this simple method to return method list supported by both
irb(main):054:0> def print_methods(obj)
irb(main):055:1> obj.methods.each do |mm|
irb(main):056:2* puts mm
irb(main):057:2> end
irb(main):058:1> end
Only method difference between print_methods(Object) and print_methods(Class) is
Nesting
if Nesting means inheritance, Is Object similar to the sealed class??
Can someone clarify me what is all this?
Update: To Edds comment
Interestingly i see lot of differences in the method list in
c=Class.new
print_methods(c)
&
o=Object.new
print_methods(o)
Now I understand Instance of a class is really an class instance (And this class instance is actually a Object) not an object instance. And even this instance allow me to span another instances
xx = c.new //works - c is an Object / and xx is a instance of an Object c
yy = o.new //nope - o is already a instance of an Object, so it cannot be instantiated again
So Finally, Object is really an instance of a Class. Because
xx.is_a? Class
is false, but
xx.is_a? Object
returns true
Am i right, ??
Basically the key thing to understand is that every class is an instance of the Class class and every class is a subclass of Object (in 1.8 - in 1.9 every class is a subclass of BasicObject). So every class is an object in the sense that it is an instance of a subclass of Object, i.e. Class.
Of course this means that Class is an instance of itself. If that makes your brain hurt, just don't think about it too deeply.
Object and Class are is_a? Object
x.is_a? y returns true if x.class == y or x.class < y, i.e. if x's class is y or x's class inherits from y. Since every class inherits from object x.is_a? Object returns true no matter what x is. (In 1.8 anyway, in 1.9 there's also BasicObject which is now the most basic class in the inheritance hierarchy).
They are also is_a? Class
Both Object and Class are indeed classes, so that should not be surprising.
They are also instance_of? Class, but not instance_of? Object.
Unlike is_a?, x.instance_of? y only returns true if x.class == y, not if x.class is a subclass of y. So since both x and y are instance_of? Class, they're not instance_of? Object.
right, nothing can be instance of object.
That's not true. Object.new.instance_of? Object is true.
kind_of?
kind_of? is an alias for is_a?, so see above.
So both are exactly same, then why do we have both these.?
It should be pointed out that everything up to now is true for all classes. E.g. String.is_a? Object, String.is_a? Class and String.instance_of? Class are true and String.instance_of? Object is false for the same reasons as above. (Also String.is_a? String and String.instance_of? String are both false for the same reasons - String is a class, not a string).
You can not conclude from this that all the classes are the same. They're just all instances of the same class.
Comparing methods
Since both Object and Class are classes, they both have all the instance methods defined by Class. Class additionally has the singleton method nesting. nesting tells you which module you're currently nested in, it has nothing to do with inheritance.
For any given class TheClass.methods will return the instance methods defined by Class (e.g. superclass, which returns the class which TheClass inherits from, and new which creates a new instance of TheClass) plus the singleton methods defined by that class.
Anyway methods only tells you which methods can be called directly on a given object. It does not tell you which methods can be called on an instance of a class. For that you can use instance_methods, which returns significantly different results for Object and Class.
In Ruby, everything is an Object including classes and modules. Object is the most low-level class (well, in Ruby 1.9.2 there is also BasicObject but this is an other story).
See the following output.
> Object.ancestors
# => [Object, Kernel, BasicObject]
> Class.ancestors
# => [Class, Module, Object, Kernel, BasicObject]
> Module.ancestors
# => [Module, Object, Kernel, BasicObject]
> String.ancestors
# => [String, Comparable, Object, Kernel, BasicObject]
As you can see, both Class and Module inherits from Object.
Back to your original assertions, you have to understand the difference bewteen
is_a?
kind_of'
instance_of?
They are not interchangeable. is_a? and kind_of? returns true if other is the same class or an ancestor. Conversely, instance_of? returns true only if other is the same class.
> Class.is_a? Object
# => true
> Class.kind_of? Object
# => true
> Class.instance_of? Object
# => false
One of the answers mentions this:
Basically the key thing to understand is that every class is an
instance of the Class class and every class is a subclass of Object.
So every class is an object in the sense that it is an instance of a
subclass of Object, i.e. Class.
I just want to word it differently for those who have a little brain twist. First ask yourself: What is an instance in programming? And what is a subclass in programming? An instance is just a realized variation of a blueprint (the Class). A subclass is simply a class (blueprint) that inherits from another class (blueprint). So when you create a new class:
class Apple
end
Apple is an instance of Class, that is, it is a realized variation of the blueprint. It takes the blueprint and fills in the details (methods and variables) with its own variation. Well, the blueprint inherits from another blueprint, which is Object. So every class is an instance of Class, which is a subclass of Object.
class A
end
A.superclass
=> Object
A.class
=> Class
Note Class has Module in its inheritance chain (Module included in Class as a mixin perhaps since Class's parent is Object?).
A.is_a?(Module)
=> true
Instances (A.new) of class A will have their own realized variations of A. But they are object instances. So we must distinguish class instances (e.g. class A end) and object instances ( a = A.new). Object instances have a different inheritance chain. They are a realized variation of a class instance blueprint, not a variation of class Class.
This means in their inheritance chain is not Class or Module. But rather other object instances, so if A has object instances and B has object instances and A inherits from B, when we instantiate a new object instance of A, this instance will have B instances in its inheritance chain.
They will also inherit from Object, since everything in Ruby inherits from Object.
a = A.new
=> #<A:0x007f966449b8d8>
a.is_a?(Class)
=> false
a.is_a?(Module)
=> false
a.is_a?(Object)
=> true
And this is the best way to think about it all. Do not go too deep with your thinking. Accept this as I have written it.
Ramesh, in ruby everything is an object, and a Class is no exception.
try this in irb
ruby-1.9.2-p136 :001 > o = Object.new
=> #<Object:0x000001020114b0>
ruby-1.9.2-p136 :002 > o.is_a? Class
=> false
ruby-1.9.2-p136 :003 > o.is_a? Object
=> true
in this case, I've created an instance of an Object, and checked if it's a class (false) or a Object (true).
A Class in ruby, is some kind of template object used to create instances of that class. Sorry that this is not super clear. The key concept is that ruby is a pure object oriented language, as opposed to Java.
The class/metaclass hierarchy is always a little puzzling :) Just for comparison, here's the one in Smalltalk; in Ruby, the setup is based on the same principles, except it doesn't have the Behavior and ClassDescription distinctions, and there are modules and eigenclasses to take into account.
A full explanation of the Smalltalk object model is available in Pharo by Example, as pointed by this related question.
As _why writes in this article
objects do not store methods, only classes can.
The first couple sections have some good points about classes vs objects
Think of Classes as global objects.
Related
From Wikibooks' Ruby Programming/Overview:
When I said that every Ruby object has a class, I lied. The truth is, every object has two classes: a “regular” class and a singleton class. An object’s singleton class is a nameless class whose only instance is that object. Every object has its very own singleton class, created automatically along with the object. Singleton classes inherit from their object’s regular class and are initially empty, but you can open them up and add methods to them, which can then be called on the lone object belonging to them. This is Ruby’s secret trick to avoid “class methods” and keep its type system simple and elegant
The above passage says that Ruby's secret trick to avoid class methods. I don't understand what the author means here. Where is Ruby stopping us to avoid class methods? for an example, look at the example shown below
class Raj
def self.hi
puts 'Hi'
end
def hello
puts 'hello'
end
end
object=Raj.new
object.hello
Raj.hi
As you can see in the preceding example, the class methods can still be created.
yes?
I understand that there are no true class methods in Ruby; instead, they are methods that are created for the Raj object.
But, in any case, it's allowing me to create the method 'hi,' right?
So, what does it mean when it says, 'This is Ruby's secret trick for avoiding "class methods" and keeping its type system simple and elegant'?
I understand that there are no true class methods in Ruby; instead, they are methods that are created for the Raj object.
That's exactly it, though.
def self.hi
puts 'Hi'
end
This is not a class method or static method. Those don't exist in Ruby. That's the whole point. Your class Raj defines an object of type Class. We can see its type with the #class function.
> Raj.class
=> Class
We can also see its ancestors.
> Raj.class.ancestors
=> [Class, Module, Object, PP::ObjectMixin, Kernel, BasicObject]
Class inherits from Module, since (for the most part) classes can do everything modules can. Module, in turn, inherits from Object, which has some modules of its own mixed in (PP:ObjectMixin is for pretty-printing, and Kernel gets you the nice helpers like puts) and eventually inherits from the root class BasicObject.
But this isn't the whole story, for Raj has its own class as well: its singleton class. We can see the full story by calling #singleton_class instead of #class.
> Raj.singleton_class.ancestors
=>
[#<Class:Raj>,
#<Class:Object>,
#<Class:BasicObject>,
Class,
Module,
Object,
PP::ObjectMixin,
Kernel,
BasicObject]
Now there's a lot more going on. Raj is an instance of the singleton class of Raj, which inherits from the singleton class of Object, which in turn inherits from the singleton class of BasicObject, which inherits from Class and all of the stuff we saw before.
So when you define a method on the class Raj, you're defining it (as an instance method) on the singleton class #<Class:Raj>. And that class (currently) has one instance: Raj.
By the way, it's also useful to know that the term "singleton class" is a bit of a lie. As you can see, the class is very much not a singleton in general. For instance, the singleton class of Object, called #<Class:Object> above, actually has several instances: Object, Raj, String, and most Ruby classes. Personally, I prefer to call them eigenclasses for that reason, but "singleton class" is the official (and more well-known) term.
The author is talking about the singleton class in this sentence, there is a really nice article to deep dive into ruby singleton class: https://medium.com/#leo_hetsch/demystifying-singleton-classes-in-ruby-caf3fa4c9d91
Here is a nice example extracted from this article:
class Vehicle
def initialize(kms)
#kms = kms
end
def drive
puts "let's go!"
end
end
car = Vehicle.new(1000)
bus = Vehicle.new(3000)
def car.drive
print "I'm driving a car! "
super
end
car.drive # "I'm driving a car! let's go!"
bus.drive # "let's go!"
As you can see, here the #drive method has been overridden but only for the car object, the bus object is still using the #drive method defined in the Vehicle class.
This new method is defined on the singleton class (or shadow class) of the object, this is allowing you to define new methods on the fly on an object without polluting all the objects of this class.
This means that Ruby doesn't implement class methods.
Indeed, the Ruby OBJECT Model, allows you to "emulate" the definition of class methods by defining instance methods on the Eigenclass:
class Greeting
def self.hello
'hello world!'
end
def self.eigenclass
class << self
self
end
end
end
Greeting.eigenclass # => #<Class:Greeting>
Greeting.eigenclass.name # => nil
Greeting.singleton_methods # => [:hello, :eigenclass]
Greeting.eigenclass.instance_methods(false) # => [:hello, :eigenclass]
First, we define a Greeting.eigenclass method. This method returns self in the context of the eigenclass — by using the class << self ... end syntax. In this case, self contains an unnamed instance of the class Class (a.k.a an anonymous class). This anonymous class keeps track of the class to which it is attached — the Greeting class in our case.
Then, we can see that the singleton methods of the Greeting class are the instance methods of the Greeting eigenclass.
Feel free to have a look to this very detailed article to learn more about this concept.
To illustrate #Sébastien P.'s answer:
dice = [1,2,3,4,5,6] #an ordinary array instance
def dice.throw #now it has an extra
sample
end
p dice.throw #=>3
I was reading another question with an answer that mentions using the Module#const_get instance method to find a class in a module. For example:
module M
class C
end
end
p M.const_get 'C'
#=> M::C
I was curious about the const_get method so I used ri and found:
ri Module#const_get
...
This method will recursively look up constant names if a namespaced
class name is provided. For example:
module Foo; class Bar; end end
Object.const_get 'Foo::Bar'
...
It seems like Object::const_get is a singleton method. Using it in our context works:
module M
class C
end
end
p Object.const_get 'M::C'
#=> M::C
But there's nothing documented about that singleton method:
ri Object::const_get
Nothing known about Object::const_get
ri Object.const_get
Nothing known about Object.const_get
This confused me because I know a Module is an Object but an Object is not a Module:
Module.ancestors
#=> [Module, Object, Kernel, BasicObject]
Object.ancestors
#=> [Object, Kernel, BasicObject]
Except then I used the Object#is_a? instance method to check and saw that I was wrong about that:
Module.is_a? Object
#=> true
Object.is_a? Module
#=> true
What started as an innocent ri query has led me to be confused about the entire Ruby object model.
Why does Object.is_a? Module #=> true if Module is not in Objects ancestor chain?
How does Object know about the const_get method?
This is an artifact of the ill-understood separation between an object's class and an object's singleton class, a sort of shadow class that each class uses for things like this.
You can access this easily in Ruby 2.5+ with the singleton_class method:
Object.singleton_class.ancestors
# => [#<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]
Where Module makes an appearance here, so that's how those methods get mixed in and are callable via Object.
Object itself has a comparatively dull inheritance chain:
Object.ancestors
#=> [Object, Kernel, BasicObject]
Every object in Ruby has a class, even Class is an Object, which also has an associated Class.
I think your confusion stems from looking at Object from two directions at once:
Object is a class so Object.ancestors can be used to look at the inheritance hierarchy. This tells you that Object < Kernel is true and Object < Module is false.
Classes in Ruby are also objects, specifically they're instances of the Class class. This tells you that Object.is_a? Class and Object.is_a? Module in the same way that 'pancakes'.is_a? String. And that Object.const_get is a method call in the same way that 'pancakes'.upcase is a method call.
You can think of some_obj.is_a? SomeClass as a shorter way of saying some_obj.class.ancestors.include? SomeClass.
Answering your specific questions:
Why does Object.is_a? Module #=> true if Module is not in Object's ancestor chain?
Because is_a? and ancestors are looking at different things.
How does Object know about the const_get method?
Because Object is an instance of the Class class and Class includes Module in its ancestors. Similarly to how 'pancakes' is an instance of the String class which has Kernel in its ancestors so 'pancakes' has an object_id method.
Object.is_a? Module #=> true
is_a? is asking whether Object is an instance (or specialised instance) of Module. Class is a subclass of Module so all instances of Class are really just specialised instances of Module. Since Object is an instance of Class, it follows that Object is also an instance of Module.
Module#const_get
const_get is an instance method defined within the Module class. Since Object is an instance of Module (for reasons discussed above), it has access to Module#const_get.
Is there a way of checking whether an object has a singleton class without creating one?
Other than stated in Check if an object has a singleton class, it is not true that every object has a singleton class (see proof under https://repl.it/DuVJ/2).
The following approaches came into my mind, but don't work:
obj.singleton_class
This automatically creates a new singleton class if none exists (see
https://ruby-doc.org/core-1.9.2/Object.html#method-i-singleton_class).
Using ObjectSpace:
has_singleton_class = ObjectSpace.each_object(Class).any? do |klass|
klass < self.class && klass.singleton_class? && self.is_a?(klass)
end
This is very slow and might not work under jRuby as ObjectSpace might not
be available.
obj.singleton_methods only works if the singleton class has at least
one method.
You can use the ancestors method. Because you want to check if a class (not an object) is a singleton, you can fetch all the modules mixed within the class and verify if any of those are a singleton class.
class Klass
include Singleton
end
Klass.ancestors.include? Singleton # true
In ruby, for creating a singleton you should include a Singleton module. So if you check for that module it means that that class is a singleton. Ruby's base class inheritance of the module class meaning that you have access to use the ancestors method.
References:
https://ruby-doc.org/core-2.1.0/Module.html#method-i-ancestors
https://ruby-doc.org/core-2.2.0/Class.html
https://ruby-doc.org/stdlib-2.1.0/libdoc/singleton/rdoc/Singleton.html#module-Singleton-label-Usage
An unelegant way I found out is to try:
Marshal.dump obj
If obj has a singleton class (without custom serialization strategy), we get a TypeError:
TypeError: singleton can't be dumped
The ancestors method returns an ordered list of classes and modules that corresponds with the method lookup sequence. below example, instances of the
class CheckKlass will search for methods in CheckKlass, Object, Kernel, and BasicObject before calling A#method_missing.
class CheckKlass; end
CheckKlass.ancestors # => [CheckKlass, Object, Kernel, BasicObject]
And if Singleton is included this would look like below
class CheckKlass
include Singleton
end
This could give you =>
[CheckKlass, Singleton, ActiveSupport::ToJsonWithActiveSupportEncoder, Object, PP::ObjectMixin, ActiveSupport::Dependencies::Loadable, JSON::Ext::Generator::GeneratorMethods::Object, ActiveSupport::Tryable, Kernel, BasicObject]
I'm confused about these two class when I was reading Module document.
First of all, I saw there is a way to set the named constant to the given object.
Object.const_set("FOO", 40)
But I check ruby doc, there is no const_set in Object method, then I found out it was defined in Module.
I thought Object is the default root of all Ruby objects. Why it can use module method? I am confused about the relationship between those.
As shown below :const_set is an instance method stored in Module:
Module.instance_methods(false).include? :const_set #=> true
Also note that Object is an instance of Class:
Object.instance_of? Class #=> true
And Class is a subclass of Module:
Class.superclass #=> Module
All of this means that instance methods defined within Module are available to Class objects via inheritance. So any instance of Class (such as Object) has at its disposal all the instance methods (including :const_set) stored in Module.
In ruby, basically every class is an instance of the Class class and every class is a subclass of Object. And both Object and Class are classes. If you do
Object.is_a?class
Class.is_a?class
In both cases, you will get a true value. Class has Module as one of the ancestor, therefore, you can use
Object.const_set("FOO", 40)
There is also #ancestors to give you some more context on the object model.
> Module.ancestors
=> [Module, Object, PP::ObjectMixin, Kernel, BasicObject]
I've been reading a lot about ruby classes vs objects and I came to this conclusion
There is a concept called "class" and we have the following classes:
BasicObject
which is the superclass of
Object
which is the superclass of
Module
which is the superclass of
Class
so:
the "class" Class is a subclass of "class" Object
Because all of the above "Class, Module, Object, Basic Object" are instances of "class" the concept. Instance_of? Class will
return true for all them
On the other hand (Object.new).instance_of? Class will return false, because (Object.new) is an instance of "class" Object
questions:
Class.is_a? Object is true because Class is a subclass of Object but Object.is_a? Class returns true as well, is that because Class here refers to the bigger class concept? If so why? isn't that confusing? How would I know which class is which?
You have several things wrong.
(2.) The reason Class, Module, Object, and Basic Object are instances of Class is not because Class < Module < Object < BasicObject. It has nothing to do with it.
(3.) (Object.new).instance_of? Class returns false not because Object.new is an instance of Object. It is because it is not an instance of Class.
Class.is_a? Object is true not because [the mentioned] Class is a subclass of Object. It is because (the mentioned) Class is an instance of Class (which is not mentioned), which is a subclass of Object.
The answer to the question is: Object.is_a? Class returns true because Object is an instance of Class.
If you want to know the class of an instance, use instance_of? or class methods.
3.is_a?(Object) # => false
3.is_a?(Fixnum) # => true
3.class # => Fixnum
What's really going in is that Ruby is cheating. Matz wanted to copy the elegance of smalltalk when he designed Ruby, namely the rule
Everything is an object.
To put that more technically
Everything is an instance of the Object class or one of its subclasses.
However, as you've seen, that simple rule leads to some confusing situations. How does all of that craziness work? Like I said, it cheats. The Ruby interpreter is hard coded to lie about certain relationships so that the golden rule of "everything is an object" looks like it's unbroken. Here it is straight from the source:
void Init_class_hierarchy(void)
{
/* the normal hierarchy we know and love */
rb_cBasicObject = boot_defclass("BasicObject", 0);
rb_cObject = boot_defclass("Object", rb_cBasicObject);
rb_cModule = boot_defclass("Module", rb_cObject);
rb_cClass = boot_defclass("Class", rb_cModule);
/* sneaky stuff to force consistent behavior!!! */
rb_const_set(rb_cObject, rb_intern_const("BasicObject"), rb_cBasicObject);
RBASIC_SET_CLASS(rb_cClass, rb_cClass);
RBASIC_SET_CLASS(rb_cModule, rb_cClass);
RBASIC_SET_CLASS(rb_cObject, rb_cClass);
RBASIC_SET_CLASS(rb_cBasicObject, rb_cClass);
}
And there are a lot more cases in the source code where built in classes need special treatment in order to give the "least surprising" result. Basically when it comes down to abstract internal stuff like this, don't worry about it. Just assume that things will behave as expected.