为什么不将新颜色传递到哈希中(仍在学习 def 方法，作业是编写一个 def 方法来放入新颜色)

Question

boat_1 = { "name" => "S. S. Minnow", "color" => "white", "price" => 20000 }
boat_2 = { "name" => "Titanic", "color" => "black", "price" => 700000000 }
class Boat
def initialize(name, color, price)
@name = name
@color = color
@price = price
end
def name
@name
end
def color
@color
end
def boat_2(text)
@color = text 
end
end
boat_1 = Boat.new("S. S. Minnow", "white", 20000 )
boat_2 = Boat.new("Titanic", "black", 700000000)
p boat_1
p boat_2
p boat_1.name
boat_2.color = "red"
p boat_2.color

我不确定我是否只是没有正确地表达方法

这是我训练营的实际问题，如果有帮助的话

重写两个散列以使用类代替。还要编写检索名称和颜色的方法，以及重新定义颜色的方法。

我真的以为它会像传递一个新值到哈希一样简单，但到目前为止我所尝试的都没有成功。

Answer 1

首先在属性上编写简单的读取器和写入器我认为应该使用attr_reader, attr_writer或者attr_accesors

说，我认为你的代码是正确的，但你的写作方法上的颜色必须是def attribuute_name =()废话废话结束，请注意=符号在名称。所以你的类应该是这样的:

class Boat

def initialize(color, name, price)
@color = color
@name = name
@price = price
end
def name
@name
end

def color
@color
end
def color=(color)
@color = color
end
end

使用它:

[2] pry(main)> 
[8] pry(main)* [8] pry(main)* [8] pry(main)* [8] pry(main)* [8] pry(main)* [8] pry(main)* [8] pry(main)* [8] pry(main)* [8] pry(main)* [8] pry(main)* [8] pry(main)* [8] pry(main)* [8] pry(main)* [8] pry(main)* [8] pry(main)* [8] pry(main)* [8] pry(main)* [8] pry(main)* [8] pry(main)* [8] pry(main)* [8] pry(main)* => :color=
[9] pry(main)> b = Boat.new "red", "Pete", 56
=> #<Boat:0x00007f9d7534c230 @color="red", @name="Pete", @price=56>
[26] pry(main)> b.color= "blue"
=> "blue"
[35] pry(main)> pp b
#<Boat:0x00007f9d7534c230 @color="blue", @name="Pete", @price=56>
=> #<Boat:0x00007f9d7534c230 @color="blue", @name="Pete", @price=56>

Answer 2

我不确定我是否理解了这个问题，但这是一个我相信的答案。

我们得到了两个哈希值:

boat_1 = { "name"=>"S. S. Minnow", "color"=>"white", "price"=>20000 }
boat_2 = { "name"=>"Titanic", "color"=>"black", "price"=>700000000 }

如果我们想获得，例如，boat_1的键"color"的值，我们可以写

boat_1["name"]
#=> "S. S. Minnow"

其中#=>指定实例方法hash#[]对于给定的键的返回值，键是该方法的参数。

类似地，如果我们希望将"color"的值更改为"red"，我们可以使用hash# []=:

方法

boat_1["color"] = "red"

我猜这个问题想让你创建一个类，比如"Boat"(当然名字不重要)，并创建两个实例，也许命名为boat1和boat2，并展示如何在这些实例上执行与上面显示的两个哈希操作相当的操作。

你可以这样写这个类:

class Boat
attr_accessor :color 
attr_reader :name, :price
def initialize(name, color, price)
@name = name
@color = color
@price = price
end
end

解析类定义时，在self(等于Boat)上调用类方法module# attr_reader。该方法只创建两个实例方法:

def name
@name
end

def price
@price
end

这些方法称为getter。

类似地，当解析类定义时，也在self上调用类方法Module::attr_accessor。它创建了getter:

def color
@color
end

和setter(实例方法):

def color=(new_color)
@color = new_color
end

我想强调attr_accessor,attr_reader(和Module::attr_writer)仅仅是为了方便编码器而提供的;如果Ruby内核中没有提供getter和setter，那么编码器只需编写任何所需的getter和setter即可。

然后我们将创建如问题中所示的实例。

boat_1 = Boat.new("S. S. Minnow", "white", 20000)
#=> #<Boat:0x00007ff90c1d2358 @name="S. S. Minnow", @color="white",
#     @price=20000>
boat_2 = Boat.new("Titanic", "black", 700000000)
#=> #<Boat:0x00007ff90c1c03d8 @name="Titanic", @color="black",
#     @price=700000000>

要获得boat1的密钥"name"的值，我们可以这样写:

boat_1.name
#=> "S. S. Minnow"

将boat_1的键"color"的值更改为"red"我们会写:

boat_1.color = "red"
#=> "red"
boat_1
#=> #<Boat:0x00007ff90c1d2358 @name="S. S. Minnow", @color="red",
#     @price=20000>

这是否意味着哈希和类在某种意义上是可以互换的?

假设我们希望向现有散列中添加一个键值对。我们可以使用前面提到的Hash#[]方法:

boat-1["length"] = 6.2

要对类做类似的事情，我们需要重写类定义(如果动态完成，这将是不可行的)。

如果希望删除哈希中的键值对，可以使用hash# delete方法:

boat_1.delete("price")

同样，要对类做这一点，我们必须重写类定义。

假设我们希望更改键"name"的值。对于哈希值，我们可以这样写:

boat_1[:name] = "Pinta"

如果我们尝试对类实例这样做，我们将得到以下结果:

boat_1.name = "Pinta"   
#=> NoMethodError: undefined method 'name=' for #<Boat:0x00007ff90c1d2358>

如果编码器不希望更改这个值，这可能是使用类而不是散列的原因。

显然，我们可以用哈希做很多不适合使用类实例的事情(比如合并哈希)，反之亦然。