Ruby 使用Var命名Var

我正在尝试动态创建数组，并且正在处理这些代码，但是我没有取得任何进展

从

位置开始

：

locations = {"boston" => 1, "new_york" => 2 , "miami" => 3}

并使用：

locations.each {
|city, id|  puts "#{city}_angels"
}

---

理想的结果是初始化三个数组：

boston\u angels

，

new\u york\u angels

，

miami\u angels

，根据对该问题的评论，有很多方法可以从源可枚举项构造哈希<代码>每个带有\u对象的\u都是我的最爱之一：

locations.keys.each_with_object({}) {|city, out| out[city] = [] }

注入

/

减少

是另一个选项：

locations.keys.inject({}) {|h, city| h[city] = []; h }

您还可以创建一个

[city，[]

数组，然后将其转换为哈希：

Hash[*locations.flat_map {|city, id| [city, []] }]

或者如果您使用的是Ruby 2.1：

locations.keys.map {|k| [k, []] }.to_h

---

根据对这个问题的评论，有很多方法可以从源可枚举项构造哈希<代码>每个带有\u对象的\u都是我的最爱之一：

locations.keys.each_with_object({}) {|city, out| out[city] = [] }

注入

/

减少

是另一个选项：

locations.keys.inject({}) {|h, city| h[city] = []; h }

您还可以创建一个

[city，[]

数组，然后将其转换为哈希：

Hash[*locations.flat_map {|city, id| [city, []] }]

或者如果您使用的是Ruby 2.1：

locations.keys.map {|k| [k, []] }.to_h

---

根据对这个问题的评论，有很多方法可以从源可枚举项构造哈希<代码>每个带有\u对象的\u都是我的最爱之一：

locations.keys.each_with_object({}) {|city, out| out[city] = [] }

注入

/

减少

是另一个选项：

locations.keys.inject({}) {|h, city| h[city] = []; h }

您还可以创建一个

[city，[]

数组，然后将其转换为哈希：

Hash[*locations.flat_map {|city, id| [city, []] }]

或者如果您使用的是Ruby 2.1：

locations.keys.map {|k| [k, []] }.to_h

---

根据对这个问题的评论，有很多方法可以从源可枚举项构造哈希<代码>每个带有\u对象的\u都是我的最爱之一：

locations.keys.each_with_object({}) {|city, out| out[city] = [] }

注入

/

减少

是另一个选项：

locations.keys.inject({}) {|h, city| h[city] = []; h }

您还可以创建一个

[city，[]

数组，然后将其转换为哈希：

Hash[*locations.flat_map {|city, id| [city, []] }]

或者如果您使用的是Ruby 2.1：

locations.keys.map {|k| [k, []] }.to_h

---

这个问题与哈希

位置的值无关，所以让我们从以下内容开始：

cities = locations.keys
  #=> ["boston", "new_york", "miami"]

其他三种方法可以做到这一点：

#1

Hash[cities.map { |c| [c, []] }]
  #=> {"boston"=>[], "new_york"=>[], "miami"=>[]}

使用Ruby 2.1+可以将
散列[arr]
写成
arr.to\u h

#2

cities.reduce({}) { |h,city| h.merge({ city=>[] }) }

#3

h = Hash.new { |h,k| h[k] = [] }
h.values_at(*cities)
h
  #=> {"boston"=>[], "new_york"=>[], "miami"=>[]}

这个问题与哈希
位置的值无关，所以让我们从以下内容开始：

cities = locations.keys
  #=> ["boston", "new_york", "miami"]

其他三种方法可以做到这一点：

#1

Hash[cities.map { |c| [c, []] }]
  #=> {"boston"=>[], "new_york"=>[], "miami"=>[]}

使用Ruby 2.1+可以将
散列[arr]
写成
arr.to\u h

#2

cities.reduce({}) { |h,city| h.merge({ city=>[] }) }

#3

h = Hash.new { |h,k| h[k] = [] }
h.values_at(*cities)
h
  #=> {"boston"=>[], "new_york"=>[], "miami"=>[]}

这个问题与哈希
位置的值无关，所以让我们从以下内容开始：

cities = locations.keys
  #=> ["boston", "new_york", "miami"]

其他三种方法可以做到这一点：

#1

Hash[cities.map { |c| [c, []] }]
  #=> {"boston"=>[], "new_york"=>[], "miami"=>[]}

使用Ruby 2.1+可以将
散列[arr]
写成
arr.to\u h

#2

cities.reduce({}) { |h,city| h.merge({ city=>[] }) }

#3

h = Hash.new { |h,k| h[k] = [] }
h.values_at(*cities)
h
  #=> {"boston"=>[], "new_york"=>[], "miami"=>[]}

这个问题与哈希
位置的值无关，所以让我们从以下内容开始：

cities = locations.keys
  #=> ["boston", "new_york", "miami"]

其他三种方法可以做到这一点：

#1

Hash[cities.map { |c| [c, []] }]
  #=> {"boston"=>[], "new_york"=>[], "miami"=>[]}

使用Ruby 2.1+可以将
散列[arr]
写成
arr.to\u h

#2

cities.reduce({}) { |h,city| h.merge({ city=>[] }) }

#3

h = Hash.new { |h,k| h[k] = [] }
h.values_at(*cities)
h
  #=> {"boston"=>[], "new_york"=>[], "miami"=>[]}

它们需要是局部变量吗？为什么不创建一个包含波士顿、纽约和迈阿密密钥的哈希表呢？我想一个哈希表可以使用数组作为其值。如何初始化空数组？它们是否需要是局部变量？为什么不创建一个包含波士顿、纽约和迈阿密密钥的哈希表呢？我想一个哈希表可以使用数组作为其值。如何初始化空数组？它们是否需要是局部变量？为什么不创建一个包含波士顿、纽约和迈阿密密钥的哈希表呢？我想一个哈希表可以使用数组作为其值。如何初始化空数组？它们是否需要是局部变量？为什么不创建一个包含波士顿、纽约和迈阿密密钥的哈希表呢？我想一个哈希表可以使用数组作为其值。如何初始化空数组？