Les attributs sont des propriétés spécifiques d'un objet. Les méthodes sont les capacités d'un objet.
En Ruby, toutes les variables d'instance (attributs) sont privées par défaut. Cela signifie que vous n'y avez pas accès en dehors de la portée de l'instance elle-même. Le seul moyen d'accéder à l'attribut consiste à utiliser une méthode d'accès.
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"
Comme il s'agit d'un comportement vraiment commun, Ruby fournit une méthode pratique pour définir les méthodes d'accès: attr_accessor, attr_writer et attr_reader.
Les attributs ne sont qu'un raccourci. Si vous utilisez attr_accessor pour créer un attribut, Ruby déclare simplement une variable d'instance et crée des méthodes de lecture et de définition pour vous.
Depuis que vous avez demandé un exemple:
class Thing
attr_accessor :my_property
attr_reader :my_readable_property
attr_writer :my_writable_property
def do_stuff
# does stuff
end
end
Voici comment vous utiliseriez la classe:
# 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"
Les attributs sont, à proprement parler, les variables d'instance d'une instance de classe. En termes plus généraux, les attributs sont généralement déclarés à l'aide des méthodes de type attr_X, tandis que les méthodes sont simplement déclarées telles quelles.
Un exemple simple pourrait être:
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 distinction entre ces deux est quelque peu arbitraire en Ruby puisqu’aucun accès direct n’est spécifiquement prévu. Cela contraste assez fortement avec d'autres langages tels que C, C++ et Java, où l'accès aux propriétés des objets et aux méthodes d'appel se fait par deux mécanismes différents. Java en particulier a des méthodes accesseur/mutateur qui sont épelées en tant que telles, alors qu'en Ruby, elles sont impliquées par leur nom.
C'est souvent le cas, comme dans l'exemple, où la différence entre un "accesseur d'attribut" et une méthode d'utilitaire fournissant des données basées sur la valeur d'un attribut, telle que nom_troncée, est mineure.
class MyClass
attr_accessor :point
def circle
return @circle
end
def circle=(c)
@circle = c
end
end
Un attribut est une propriété de l'objet. Dans ce cas, j'utilise la méthode de classe attr_accessor pour définir la propriété: point avec des méthodes implicites de getter et de setter pour point.
obj = MyClass.new
obj.point = 3
puts obj.point
> 3
La méthode 'circle' est un getter explicitement défini pour la variable d'instance @circle. 'circle =' est un outil de définition explicitement défini pour la variable d'instance @circle.
J'ai entendu le mot "attribut" se référer, dans les cercles spécifiques à Ruby, à toute méthode qui ne prend pas d'arguments.
class Batman
def favorite_ice_cream
[
'neopolitan',
'chunky monkey',
'chocolate',
'chocolate chip cookie dough',
'whiskey'
].shuffle[0]
end
end
Dans ce qui précède, my_newest_batman.favorite_ice_cream serait un attribut.