Quelle est la différence entre les méthodes et les attributs dans Ruby?
5 réponses
les Attributs sont des propriétés spécifiques de l'objet. Les méthodes sont les capacités d'un objet.
dans Ruby, toutes les variables d'instance (attributs) sont privées par défaut. Cela signifie que vous n'avez pas accès à l'extérieur de la portée de l'instance elle-même. La seule façon d'accéder à l'attribut est à l'aide d'une méthode d'accesseur.
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"
parce que c'est un comportement vraiment commmon, Ruby fournit une méthode pratique pour définir les méthodes accessor: attr_accessor,attr_writer et attr_reader.
Attributs sont juste un raccourci. Si vous utilisez attr_accessor pour créer un attribut, Ruby déclare juste une variable d'instance et crée des méthodes getter et setter pour vous.
puisque 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 utiliser 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"
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 en utilisant les 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-là est quelque peu arbitraire dans Ruby puisqu'aucun accès direct n'est spécifiquement prévu. Ceci contraste fortement avec d'autres langages comme C, ou C++ et Java où l'accès d'un objet les propriétés et les méthodes d'appel sont faites par deux mécanismes différents. Java en particulier a des méthodes accessor/mutator qui sont décrites comme telles, alors que dans Ruby elles sont implicites par leur nom.
C'est souvent le cas, comme dans l'exemple, où la différence entre un attribut "accesseur" et une méthode utilitaire qui fournit des données fondées sur la valeur d'un attribut, comme truncated_name, est mineur.
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 une méthode implicite getter et 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 setter explicitement défini pour la variable d'instance @circle.
j'ai entendu le mot "attribut" faire référence, dans les cercles spécifiques de 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
ci-dessus, my_newest_batman.favorite_ice_cream serait un attribut.