¿Cuál es la diferencia entre los métodos y atributos en Ruby?

¿Puedes darme un ejemplo?

Los atributos son propiedades específicas de un objeto. Los métodos son capacidades de un objeto.

En Ruby, todas las variables de instancia (atributos) son privadas por defecto. Significa que no tiene acceso a ellos fuera del scope de la instancia en sí. La única forma de acceder al atributo es mediante un método de acceso.

class Foo def initialize(color) @color = color end end class Bar def initialize(color) @color = color end def color @color end end class Baz def initialize(color) @color = color end def color @color end def color=(value) @color = value end end f = Foo.new("red") f.color # NoMethodError: undefined method 'color' b = Bar.new("red") b.color # => "red" b.color = "yellow" # NoMethodError: undefined method `color=' z = Baz.new("red") z.color # => "red" z.color = "yellow" z.color # => "yellow" 

Debido a que este es un comportamiento muy común, Ruby proporciona un método conveniente para definir métodos de attr_accessor : attr_accessor , attr_writer y attr_reader .

Los atributos son sólo un atajo. Si usa attr_accessor para crear un atributo, Ruby simplemente declara una variable de instancia y crea los métodos de obtención y establecimiento para usted.

Desde que pediste un ejemplo:

 class Thing attr_accessor :my_property attr_reader :my_readable_property attr_writer :my_writable_property def do_stuff # does stuff end end 

Así es como usarías la clase:

 # Instantiate thing = Thing.new # Call the method do_stuff thing.do_stuff # You can read or write my_property thing.my_property = "Whatever" puts thing.my_property # We only have a readable accessor for my_readable_property puts thing.my_readable_property # And my_writable_propety has only the writable accessor thing.my_writable_property = "Whatever" 

Los atributos son, estrictamente hablando, las variables de instancia de una instancia de clase. En términos más generales, los atributos generalmente se declaran utilizando los métodos de tipo attr_X, mientras que los métodos se declaran simplemente como están.

Un ejemplo simple podría ser:

 attr_accessor :name attr_reader :access_level # Method def truncate_name! @name = truncated_name end # Accessor-like method def truncated_name @name and @name[0,14] end # Mutator-like method def access_level=(value) @access_level = value && value.to_sym end 

La distinción entre estos dos es algo arbitraria en Ruby, ya que no se proporciona un acceso directo a ellos. Esto contrasta fuertemente con otros lenguajes como C, o C ++ y Java, donde el acceso a las propiedades de los objetos y los métodos de llamada se realiza a través de dos mecanismos diferentes. Java en particular tiene métodos de acceso / mutador que se explican como tales, mientras que en Ruby están implícitos por nombre.

A menudo es el caso, como en el ejemplo, donde la diferencia entre un “descriptor de acceso de atributo” y un método de utilidad que proporciona datos basados ​​en el valor de un atributo, como el nombre truncado, es menor.

 class MyClass attr_accessor :point def circle return @circle end def circle=(c) @circle = c end end 

Un atributo es una propiedad del objeto. En este caso, uso el método de clase attr_accessor para definir la propiedad: point junto con los métodos getter y setter implícitos para el punto.

 obj = MyClass.new obj.point = 3 puts obj.point > 3 

El método ‘círculo’ es un captador definido explícitamente para la variable de instancia @circle. ‘circle =’ es un definidor definido explícitamente para la variable de instancia @circle.

He escuchado que la palabra “atributo” se refiere, en círculos específicos de Ruby, a cualquier método que no tenga argumentos.

 class Batman def favorite_ice_cream [ 'neopolitan', 'chunky monkey', 'chocolate', 'chocolate chip cookie dough', 'whiskey' ].shuffle[0] end end 

En lo anterior, my_newest_batman.favorite_ice_cream sería un atributo.