基本上，它们伪造了Ruby所不具备的公开可访问的数据属性。

Attr_accessor只是一个方法。(这个链接应该提供更多关于它如何工作的见解——看看生成的方法对，一个教程应该告诉你如何使用它。)

关键在于，类在Ruby中不是定义(在c++和Java等语言中“只是定义”)，而是求值的表达式。在此求值期间，调用attr_accessor方法，该方法反过来修改当前类——记住隐式接收器:self。其中self是此时“打开”的类对象。

对attr_accessor和friends的需求是:

像Smalltalk一样，Ruby不允许在该对象的method1之外访问实例变量。也就是说，不能像在Java甚至Python中那样以x.y形式访问实例变量。在Ruby中，y总是被当作一个要发送的消息(或“要调用的方法”)。因此attr_*方法创建包装器，通过动态创建的方法代理实例@变量访问。 样板很糟糕

希望这能澄清一些细节。快乐的编码。

1严格来说，这并不正确，有一些“技术”围绕这一点，但没有语法支持“公共实例变量”访问。

Attr_accessor非常简单:

attr_accessor :foo

是以下操作的快捷方式:

def foo=(val)
  @foo = val
end

def foo
  @foo
end

它只不过是一个对象的getter/setter

它只是一个为实例变量定义getter和setter方法的方法。一个示例实现如下:

def self.attr_accessor(*names)
  names.each do |name|
    define_method(name) {instance_variable_get("@#{name}")} # This is the getter
    define_method("#{name}=") {|arg| instance_variable_set("@#{name}", arg)} # This is the setter
  end
end

Attr_accessor(如@pst所述)只是一个方法。它的作用是为你创建更多的方法。

这段代码:

class Foo
  attr_accessor :bar
end

等价于下面的代码:

class Foo
  def bar
    @bar
  end
  def bar=( new_value )
    @bar = new_value
  end
end

你可以自己用Ruby编写这样的方法:

class Module
  def var( method_name )
    inst_variable_name = "@#{method_name}".to_sym
    define_method method_name do
      instance_variable_get inst_variable_name
    end
    define_method "#{method_name}=" do |new_value|
      instance_variable_set inst_variable_name, new_value
    end
  end
end

class Foo
  var :bar
end

f = Foo.new
p f.bar     #=> nil
f.bar = 42
p f.bar     #=> 42

假设您有一个类Person。

class Person
end

person = Person.new
person.name # => no method error

显然，我们没有定义方法名。我们来做一下。

class Person
  def name
    @name # simply returning an instance variable @name
  end
end

person = Person.new
person.name # => nil
person.name = "Dennis" # => no method error

啊哈，我们可以读名字，但这并不意味着我们可以分配名字。这是两种不同的方法。前者称为读者，后者称为作者。我们还没有创建写入器，我们来做一下。

class Person
  def name
    @name
  end

  def name=(str)
    @name = str
  end
end

person = Person.new
person.name = 'Dennis'
person.name # => "Dennis"

太棒了。现在我们可以使用reader和writer方法写入和读取实例变量@name。不过，这是经常做的，为什么每次都浪费时间写这些方法呢?我们可以做得简单些。

class Person
  attr_reader :name
  attr_writer :name
end

即使这样也会重复。当你同时需要读取器和写入器时，只需使用访问器!

class Person
  attr_accessor :name
end

person = Person.new
person.name = "Dennis"
person.name # => "Dennis"

原理是一样的!你猜怎么着:person对象中的实例变量@name将被设置，就像我们手动设置时一样，所以你可以在其他方法中使用它。

class Person
  attr_accessor :name

  def greeting
    "Hello #{@name}"
  end
end

person = Person.new
person.name = "Dennis"
person.greeting # => "Hello Dennis"

就是这样。为了理解attr_reader, attr_writer和attr_accessor方法是如何为你生成方法的，请阅读其他答案，书籍，ruby文档。

attrr -accessor简单地为指定的属性创建getter和setter方法

我认为让新手和程序员(比如我自己)困惑的部分原因是:

“为什么我不能告诉实例它有任何给定的属性(例如，名称)，并一次性为该属性赋值?”

更一般化一点，但这就是我的想法:

考虑到:

class Person
end

我们还没有将Person定义为可以有名称或任何其他属性的东西。

那么如果我们

baby = Person.new

.．.试着给它们起个名字…

baby.name = "Ruth"

我们得到一个错误，因为在Rubyland中，对象的Person类不是与“名称”相关联或不具有“名称”的东西……然而!

但是我们可以使用任何给定的方法(参见前面的回答)来说明，“Person类(baby)的实例现在可以有一个名为'name'的属性，因此我们不仅有了获取和设置该名称的语法方法，而且这样做对我们来说是有意义的。”

再一次，从一个稍微不同和更一般的角度来解决这个问题，但我希望这有助于Person类的下一个实例找到这个线程的方法。

简单地说，它将为类定义setter和getter。

请注意,

attr_reader :v is equivalant to 
def v
  @v
end

attr_writer :v is equivalant to
def v=(value)
  @v=value
end

So

attr_accessor :v which means 
attr_reader :v; attr_writer :v 

等效于为类定义setter和getter。

如果你熟悉面向对象的概念，你必须熟悉getter和setter方法。 在Ruby中attr_accessor做同样的事情。

Getter和Setter的一般方式

class Person
  def name
    @name
  end

  def name=(str)
    @name = str
  end
end

person = Person.new
person.name = 'Eshaan'
person.name # => "Eshaan"

Setter方法

def name=(val)
  @name = val
end

Getter方法

def name
  @name
end

在Ruby中的Getter和Setter方法

class Person
  attr_accessor :name
end

person = Person.new
person.name = "Eshaan"
person.name # => "Eshaan"

定义此模块的命名属性，其中名称为symbol。Id2name，创建实例变量(@name)和读取它的相应访问方法。还创建一个名为name=的方法来设置属性。

module Mod
  attr_accessor(:one, :two)
end
Mod.instance_methods.sort   #=> [:one, :one=, :two, :two=]

我也遇到过这个问题，并写了一篇有点冗长的回答。关于这个问题已经有了一些很好的答案，但如果有人想进一步澄清，我希望我的答案能有所帮助

初始化方法

Initialize允许您在创建实例时将数据设置为对象的实例，而不是每次创建类的新实例时都必须在代码中的单独一行中设置数据。

class Person

  def initialize(name)
    @name = name
  end


  def greeting
    "Hello #{@name}"
  end
end

person = Person.new("Denis")
puts person.greeting

在上面的代码中，我们使用initialize方法通过initialize中的参数传递Dennis来设置名称“Denis”。如果我们想在不使用initialize方法的情况下设置名称，可以这样做:

class Person
  attr_accessor :name

  # def initialize(name)
  #     @name = name
  # end

  def greeting
    "Hello #{name}"
  end
end

person = Person.new
person.name = "Dennis"
puts person.greeting

在上面的代码中，我们使用person.name调用attr_accessor setter方法来设置名称，而不是在初始化对象时设置值。

这两个“方法”都做这个工作，但初始化节省了我们的时间和代码行数。

这是初始化的唯一工作。不能将initialize作为方法调用。要实际获取实例对象的值，需要使用getter和setter (attr_reader (get)、attr_writer(set)和attr_accessor(两者))。请参阅下面的详细信息。

getter, Setters (attr_reader, attr_writer, attr_accessor)

getter, attr_reader: getter的全部目的是返回特定实例变量的值。请访问下面的示例代码以了解这方面的详细信息。

class Item

  def initialize(item_name, quantity)
    @item_name = item_name
    @quantity = quantity
  end

  def item_name
    @item_name
  end

  def quantity
     @quantity
  end
end

example = Item.new("TV",2)
puts example.item_name
puts example.quantity

在上面的代码中，您在Item“example”的实例上调用方法“item_name”和“quantity”。“举例”。Item_name和example。Quantity”将返回(或“获取”)传递到“示例”中的参数值，并将它们显示在屏幕上。

幸运的是，在Ruby中有一个固有的方法，可以让我们更简洁地编写代码;attr_reader方法。请参阅下面的代码;

class Item

attr_reader :item_name, :quantity

  def initialize(item_name, quantity)
    @item_name = item_name
    @quantity = quantity
  end

end

item = Item.new("TV",2)
puts item.item_name
puts item.quantity

这种语法的工作方式完全相同，只是它为我们节省了6行代码。想象一下，如果您有5个可归属于Item类的状态?代码很快就会变长。

Setters, attr_writer: setter方法最初让我感到困惑的是，在我看来，它执行的功能与initialize方法相同。下面我将根据我的理解来解释两者的区别;

如前所述，initialize方法允许您在对象创建时设置对象实例的值。

但是，如果您想稍后(在实例创建之后)设置这些值，或者在初始化后更改它们，该怎么办呢?这是一个使用setter方法的场景。这就是区别。在最初使用attr_writer方法时，不必“设置”特定的状态。

下面的代码是使用setter方法为Item类的这个实例声明值item_name的示例。注意，我们继续使用getter方法attr_reader，这样我们就可以获取值并将它们打印到屏幕上，以防您想自己测试代码。

class Item

attr_reader :item_name

  def item_name=(str)
    @item_name = (str)
  end

end

下面的代码是使用attr_writer来再次缩短代码并节省时间的示例。

class Item

attr_reader :item_name
attr_writer :item_name

end

item = Item.new
puts item.item_name = "TV"

下面的代码重复了上面的初始化示例，其中我们使用initialize在创建时设置对象item_name的值。

class Item

attr_reader :item_name

  def initialize(item_name)
    @item_name = item_name
  end

end

item = Item.new("TV")
puts item.item_name

attr_accessor:执行attr_reader和attr_writer的函数，为您节省了多一行代码。

简单的解释，没有任何代码

以上大多数答案都使用代码。这个解释试图通过一个类比/故事来回答这个问题:

外界不能接触CIA内部机密

Let's imagine a really secret place: the CIA. Nobody knows what's happening in the CIA apart from the people inside the CIA. In other words, external people cannot access any information in the CIA. But because it's no good having an organisation that is completely secret, certain information is made available to the outside world - only things that the CIA wants everyone to know about of course: e.g. the Director of the CIA, how environmentally friendly this department is compared to all other government departments etc. Other information: e.g. who are its covert operatives in Iraq or Afghanistan - these types of things will probably remain a secret for the next 150 years. If you're outside the CIA you can only access the information that it has made available to the public. Or to use CIA parlance you can only access information that is "cleared". The information that the CIA wants to make available to the general public outside the CIA are called: attributes.

读写属性的含义:

In the case of the CIA, most attributes are "read only". This means if you are a party external to the CIA, you can ask: "who is the director of the CIA?" and you will get a straight answer. But what you cannot do with "read only" attributes is to make changes changes in the CIA. e.g. you cannot make a phone call and suddenly decide that you want Kim Kardashian to be the Director, or that you want Paris Hilton to be the Commander in Chief. If the attributes gave you "write" access, then you could make changes if you want to, even if you were outside. Otherwise, the only thing you can do is read. In other words accessors allow you to make inquiries, or to make changes, to organisations that otherwise do not let external people in, depending on whether the accessors are read or write accessors.

类中的对象可以很容易地相互访问

另一方面，如果你已经在中央情报局内部，那么你可以很容易地打电话给你在喀布尔的中央情报局特工，因为这些信息很容易获得，因为你已经在里面了。但如果你不在中情局之外，你根本就没有权限:你不能知道他们是谁(读权限)，你也不能改变他们的任务(写权限)。

类也是如此，你可以访问其中的变量、属性和方法。HTH !任何问题，请问，我希望我能澄清。

The main functionality of attr_accessor over the other ones is the capability of accessing data from other files. So you usually would have attr_reader or attr_writer but the good news is that Ruby lets you combine these two together with attr_accessor. I think of it as my to go method because it is more well rounded or versatile. Also, peep in mind that in Rails, this is eliminated because it does it for you in the back end. So in other words: you are better off using attr_acessor over the other two because you don't have to worry about being to specific, the accessor covers it all. I know this is more of a general explanation but it helped me as a beginner.

希望这对你有所帮助!

属性和访问器方法

属性是可以从对象外部访问的类组件。它们在许多其他编程语言中被称为属性。它们的值可以通过使用“点表示法”来访问，如object_name.attribute_name。与Python和其他一些语言不同，Ruby不允许从对象外部直接访问实例变量。

class Car
  def initialize
    @wheels = 4  # This is an instance variable
  end
end

c = Car.new
c.wheels     # Output: NoMethodError: undefined method `wheels' for #<Car:0x00000000d43500>

In the above example, c is an instance (object) of the Car class. We tried unsuccessfully to read the value of the wheels instance variable from outside the object. What happened is that Ruby attempted to call a method named wheels within the c object, but no such method was defined. In short, object_name.attribute_name tries to call a method named attribute_name within the object. To access the value of the wheels variable from the outside, we need to implement an instance method by that name, which will return the value of that variable when called. That's called an accessor method. In the general programming context, the usual way to access an instance variable from outside the object is to implement accessor methods, also known as getter and setter methods. A getter allows the value of a variable defined within a class to be read from the outside and a setter allows it to be written from the outside.

在下面的示例中，我们向Car类添加了getter和setter方法，以便从对象外部访问wheels变量。这不是定义getter和setter的“Ruby方式”;它只是用来说明getter和setter方法的作用。

class Car
  def wheels  # getter method
    @wheels
  end

  def wheels=(val)  # setter method
    @wheels = val
  end
end

f = Car.new
f.wheels = 4  # The setter method was invoked
f.wheels  # The getter method was invoked
# Output: => 4

上面的示例可以工作，类似的代码通常用于创建其他语言中的getter和setter方法。但是，Ruby提供了一种更简单的方法:三个内置方法，分别是attr_reader、attr_writer和attr_acessor。attr_reader方法使实例变量从外部可读，attr_writer使实例变量可写，attr_acessor使实例变量可读可写。

上面的例子可以写成这样。

class Car
  attr_accessor :wheels
end

f = Car.new
f.wheels = 4
f.wheels  # Output: => 4

在上面的例子中，wheels属性在对象外部是可读和可写的。如果我们使用attr_reader而不是attr_accessor，它将是只读的。如果我们使用attr_writer，它将只写。这三个方法本身并不是getter和setter，但是当调用时，它们为我们创建了getter和setter方法。它们是动态(以编程方式)生成其他方法的方法;这就是所谓的元编程。

第一个(较长的)示例没有使用Ruby的内置方法，应该仅在getter和setter方法中需要额外代码时使用。例如，setter方法可能需要在将值分配给实例变量之前验证数据或进行一些计算。

通过使用instance_variable_get和instance_variable_set内置方法，可以从对象外部访问(读和写)实例变量。然而，这很少是合理的，而且通常是一个坏主意，因为绕过封装往往会造成各种破坏。

另一种理解它的方法是通过attr_accessor找出它消除了哪些错误代码。

例子:

class BankAccount    
  def initialize( account_owner )
    @owner = account_owner
    @balance = 0
  end

  def deposit( amount )
    @balance = @balance + amount
  end

  def withdraw( amount )
    @balance = @balance - amount
  end
end

有以下几种方法:

$ bankie = BankAccout.new("Iggy")
$ bankie 
$ bankie.deposit(100)
$ bankie.withdraw(5)

下面的方法会抛出错误:

$ bankie.owner     #undefined method `owner'... 
$ bankie.balance   #undefined method `balance'...

从技术上讲，Owner和balance不是一个方法，而是一个属性。BankAccount类没有def owner和def balance。如果是，那么您可以使用下面的两个命令。但这两个方法都不存在。但是，您可以访问属性，就像通过attr_accessor访问方法一样!!因此有了attr_accessor这个词。属性。访问器。它像访问方法一样访问属性。

添加attr_accessor:balance，:owner允许你读写balance和owner“method”。现在您可以使用最后两个方法。

$ bankie.balance
$ bankie.owner

属性访问器attr_accessor提供了两个免费方法。

就像在Java中，它们被称为getter和setter。

很多答案都给出了很好的例子，所以我就简单点。

# the_attribute

and

# the_attribute =

在旧的ruby文档中，#表示方法。 它还可以包含一个类名前缀… MyClass # my_method

嗯。很多很好的答案。这是我的一些看法。

attr_accessor是一个简单的方法，可以帮助我们清理(DRY-ing)重复的getter和setter方法。 这样我们就可以更专注于编写业务逻辑而不用担心setter和getter。

我是ruby的新手，不得不理解下面的奇怪之处。也许将来能帮到别人。最后，就像上面提到的，其中两个函数(def myvar, def myvar=)都隐式地访问@myvar，但是这些方法可以被局部声明覆盖。

class Foo
  attr_accessor 'myvar'
  def initialize
    @myvar = "A"
    myvar = "B"
    puts @myvar # A
    puts myvar # B - myvar declared above overrides myvar method
  end

  def test
    puts @myvar # A
    puts myvar # A - coming from myvar accessor

    myvar = "C" # local myvar overrides accessor
    puts @myvar # A
    puts myvar # C

    send "myvar=", "E" # not running "myvar =", but instead calls setter for @myvar
    puts @myvar # E
    puts myvar # C
  end
end

尽管已有大量的答案，但在我看来，没有一个能解释这里涉及的实际机制。它的元编程;它利用了以下两个事实:

您可以动态地修改模块/类 模块/类声明本身就是可执行代码

好吧，想象一下:

class Nameable
  def self.named(whatvalue)
    define_method :name do whatvalue end
  end
end

我们声明了一个名为which的类方法，当用值调用时，创建一个名为name的实例方法，该实例方法返回该值。这就是元编程的部分。

现在我们将子类化这个类:

class Dog < Nameable
  named "Fido"
end

我们刚才到底做了什么?在类声明中，可执行代码执行时引用了类。因此，简单的单词named实际上是对类方法named的调用，它继承自Nameable;我们传递字符串“Fido”作为参数。

命名的类方法是做什么的?它创建一个名为name的实例方法，该方法返回该值。现在，在幕后，Dog有一个这样的方法:

def name
   "Fido"
end

不相信我?然后看这个小动作:

puts Dog.new.name #=> Fido

我为什么要告诉你这些?因为我刚才对Nameable所做的和attr_accessor对Module所做的几乎完全一样。当您使用attr_accessor时，您正在调用创建实例方法的类方法(继承自Module)。特别是，它为实例属性创建了一个getter和setter方法，实例属性的名称是您提供的参数，这样您就不必自己编写这些getter和setter方法。