¿Alguien puede explicar la paradoja Class.superclass.class.superclass?

Question

Probablemente no sea una paradoja en absoluto, pero desde la perspectiva de los novatos, seguramente parece ser así.

> Class.superclass 
=> Module 
> Class.superclass.class 
=> Class 
> Class.superclass.class.superclass 
=> Module 

Entonces, el elemento primario de una clase es el módulo, pero el módulo es una clase?

¿Cómo puedo darle sentido a esto?

Answer 1

TL; DR: Módulo es la superclase de Clase. El módulo es una instancia de Clase.

---

Déjame intentar explicarlo más claramente. Por favor perdone mis dibujos escritos a mano. No tengo ningún software de dibujo elegante.

Todas las clases en Ruby tienen 1 superclase *.

* A excepción de BasicObject, que no tiene una superclase.

Lea el gráfico anterior de esta manera: La superclase de Float es numérica. La superclase de Numeric es Object, etc ...

Cuando crea una instancia de un objeto, el objeto será una instancia de alguna clase. Por ejemplo, "Nathan" es una instancia de la clase String. También lo es "Joe" o "John". 1 es una instancia de la clase Fixnum, al igual que 2, 3, 4, etc ...

Leer el gráfico anterior así: "Joe" es una instancia de cadena. 1 es una instancia de Fixnum, etc ...

Bueno, en Ruby, a diferencia de la mayoría de los otros idiomas, Class es una clase más y también se puede instanciar, como Fixnum o String.

Leer el gráfico anterior como esto: 0,01 es una instancia de Float. String es una instancia de Class, etc ...

Date cuenta de que Fixnum es una instancia de Class, al igual que "Nathan" es una instancia de String. Al igual que "John" es una instancia de String, Float es solo una instancia de Class. ¡Cada clase es solo una instancia de Clase, incluso la Clase misma!

Cada vez que escribe una nueva clase en su aplicación, solo está instanciando un nuevo objeto cuya clase es Clase, al igual que Hash.new crea una nueva Hash o "Nathan" crea una nueva cadena.

# By running this, you will be instantiating a new Class, and 
# it will be named Post 
class Post < ActiveRecord::Base 
end 

# Here is another perfectly valid way to write the above code: 
Post = Class.new(ActiveRecord::Base) 

# you can even instantiate a Class without giving it an explicit name: 
x = Class.new(ActiveRecord::Base) 

# and since your new things are classes, they can be instantiated 
obj1 = Post.new 
obj2 = x.new 

Además, el módulo es simplemente otra instancia de la clase. Cada vez que escribe un nuevo módulo en su aplicación, solo está creando un nuevo Módulo.

# this will instantiate a new Module, and assign it to Foo 
module Foo 
end 

# Here is another perfectly valid way to write the above code: 
Foo = Module.new 

# you can even instantiate a Module without giving it an explicit name. 
m = Module.new 

Un aparte: Un módulo es solo una colección de métodos y constantes. Las clases también son una colección de métodos y constantes, pero con la funcionalidad adicional de poder crear instancias. Un módulo no puede ser instanciado. Es decir, m.new no funcionará.

Así, refiriéndose de nuevo a la gráfica superior, su pregunta se puede responder directamente:

Así matriz de una clase es el módulo, pero es un módulo de clase?

Se puede ver en el gráfico superior: Módulo es la superclase de la clase.

Desde el gráfico inferior: Módulo es una instancia de Clase.

Answer 2

• Class extends Module. Esto se demuestra en sus ejemplos primero y tercero.
• Module extends Object.
• Object extends BasicObject
• BasicObject is the root of the class hierarchy

En el segundo ejemplo Class.superclass.class, que está llamando módulo.clase. El módulo se refiere a una clase, la clase Módulo.

AnyClass.superclass.class volverá clase, a excepción de BasicObject.superclass.class

La distinción entre una clase y una instancia es importante. BasicObject es una clase. Es una clase que se extiende nil, que es una forma elegante de decir que no tiene superclase. Es la raíz del árbol. TODO es un objeto, que es otra forma de decir que todo es una instancia de alguna clase.

String Ejemplo

"Nathan" is an object. 
"Nathan" is an instance of the String class. 
"Nathan" is not a class. 
"Nathan" has no superclass, because "Nathan" is not a class. 

String is an object. 
String is an instance of the Class class. 
String's superclass is Object. 

Object is an object. 
Object is an instance of the Class class. 
Object's superclass is BasicObject. 

BasicObject is an object. 
BasicObject is an instance of the Class class 
BasicObject's superclass is nil. 

nil is an object. 
nil is an instance of the NilClass class 
nil has no superclass, because it is not a class. 

Fixnum ejemplo

1 is an object. 
1 is an instance of the Fixnum class. 
1 is not a class. 
1 has no superclass, because it is not a class. 

Fixnum is an object. 
Fixnum is an instance of the Class class. 
Fixnum's superclass is Integer. 

Integer is an object. 
Integer is an instance of the Class class 
Integer's superclass is Numeric. 

Numeric is an object. 
Numeric is an instance of the Class class. 
Numeric's superclass is Object. 

# everything below here is in the above example. 
Object is an object. 
Object is an instance of the Class class. 
Object's superclass is BasicObject. 

BasicObject is an object. 
BasicObject is an instance of the Class class 
BasicObject's superclass is nil. 

nil is an object. 
nil is an instance of the NilClass class 
nil has no superclass, because it is not a class. 

Así que, finalmente:

Class is an object. 
Class is an instance of the Class class. # this is probably the most important part. 
Class's superclass is Module # 2nd most important part 

Module is an object 
Module is an instance of the Class class. # 3rd 
Module's superclass is Object # 4th 

# everything below here is in the above examples. 
Object is an object. 
Object is an instance of the Class class. 
Object's superclass is BasicObject. 

BasicObject is an object. 
BasicObject is an instance of the Class class 
BasicObject's superclass is nil. 

nil is an object. 
nil is an instance of the NilClass class 
nil has no superclass, because it is not a class. 

en forma de tabla:

Y si le gustaría para verificar que todo es verdad, sólo puede ejecutarlo en Ruby

"Nathan".is_a?(BasicObject) # => true "Nathan" is an object. 
"Nathan".class #=> String    "Nathan" is an instance of the String class. 
"Nathan".is_a?(Class) #=> false   "Nathan" is not a class. 
"Nathan".superclass # NoMethodError  "Nathan" has no superclass, because "Nathan" is not a class. 

String.is_a?(BasicObject) #=> true  String is an object. 
String.class #=> Class     String is an instance of the Class class. 
String.superclass #=> Object    String's superclass is Object. 

Object.is_a?(BasicObject) #=> true  Object is an object. 
Object.class #=> Class     Object is an instance of the Class class. 
Object.superclass #=> BasicObject  Object's superclass is BasicObject. 

BasicObject.is_a?(BasicObject) #=> true BasicObject is an object. 
BasicObject.class #=> Class    BasicObject is an instance of the Class class 
BasicObject.superclass #=> nil   BasicObject's superclass is nil. 

nil.is_a?(BasicObject) #=> true   nil is an object. 
nil.class #=> NilClass     nil is an instance of the NilClass class 
nil.superclass # NoMethodError   nil has no superclass, because it is not a class. 

Y a partir de Clase:

Class.is_a?(BasicObject) #=> true  Class is an object. 
Class.class #=> Class     Class is an instance of the Class class. # this is probably the most important part. 
Class.superclass #=> Module    Class's superclass is Module # 2nd most important part 

Module.is_a?(BasicObject) #=> true  Module is an object 
Module.class #=> Class     Module is an instance of the Class class. # 3rd 
Module.superclass #=> Object    Module's superclass is Object # 4th 

Object.is_a?(BasicObject) #=> true  Object is an object. 
Object.class #=> Class     Object is an instance of the Class class. 
Object.superclass #=> BasicObject  Object's superclass is BasicObject. 

BasicObject.is_a?(BasicObject) #=> true BasicObject is an object. 
BasicObject.class #=> Class    BasicObject is an instance of the Class class 
BasicObject.superclass #=> nil   BasicObject's superclass is nil. 

nil.is_a?(BasicObject) #=> true   nil is an object. 
nil.class #=> NilClass     nil is an instance of the NilClass class 
nil.superclass # NoMethodError   nil has no superclass, because it is not a class.