ruby中的键值对、数组与哈希

存储键值对的更好做法是什么

数组：

class A
  DEFAULTS = [ONE = 1, TWO = 2]
end

或哈希：

class A
  DEFAULTS = {'ONE' => 1, 'TWO' => 2 }
end

哪种做法更好

TL；博士，你可能想要一份杂烩

---

第一个示例看起来像键和值，但实际上相当于：

class A
  ONE = 1
  TWO = 2
  DEFAULTS = [ONE, TWO]
end

因此，您要创建三个常量：

A.constants #=> [:DEFAULTS, :ONE, :TWO]

A::ONE #=> 1
A::TWO #=> 2
A::DEFAULTS #=> [1, 2]

A.constants #=> [:DEFAULTS]

A::DEFAULTS #=> A::DEFAULTS

A::DEFAULTS.constants #=> [:ONE, :TWO]

A::DEFAULTS::ONE #=> 1
A::DEFAULTS::TWO #=> 2

您必须通过索引

0

和

1

访问数组值：

A::DEFAULTS[0] #=> 1
A::DEFAULTS[1] #=> 2

---

第二个只创建一个常量

A.constants #=> [:DEFAULTS]

A::DEFAULTS #=> {"ONE" => 1, "TWO" => 2 }

您可以通过键

'ONE'

和

'TWO'

访问这些值：

A::DEFAULTS['ONE'] #=> 1
A::DEFAULTS['TWO'] #=> 2

---

第三种选择是使用模块进行名称空间分配：

class A
  module DEFAULTS
    ONE = 1
    TWO = 2
  end
end

这将创建嵌套常量：

A.constants #=> [:DEFAULTS, :ONE, :TWO]

A::ONE #=> 1
A::TWO #=> 2
A::DEFAULTS #=> [1, 2]

A.constants #=> [:DEFAULTS]

A::DEFAULTS #=> A::DEFAULTS

A::DEFAULTS.constants #=> [:ONE, :TWO]

A::DEFAULTS::ONE #=> 1
A::DEFAULTS::TWO #=> 2

---

问“哪种做法更好”完全没有任何意义，因为他们做的事情完全不同

第一段代码

• 创建一个名为

  TWO

  的常量，并为其赋值

  2

• 创建一个名为

  ONE

  的常量，并为其赋值

  1

• 创建一个名为

  DEFAULTS

  的常量，并将值

  [1，2]

  赋给它

第二段代码

• 创建一个名为

  DEFAULTS

  的常量，并为其赋值

  {'ONE'=>1，'TWO'=>2}

---

这两段代码实际上没有任何共同之处。在任何情况下，你都不能选择使用其中一种或另一种。

好吧，你不太明白第一种是如何工作的

在这种情况下，您将创建：

• 甲级
• A：：默认值==

  [1,2]

• A:一个
• A:两个

所以表达式

DEFAULTS=[ONE=1，TWO=2]

没有多大意义

等于

class A
  DEFAULTS = [1, 2]
  ONE = 1
  B = 2
end

因此，您需要决定如何访问这些常量：通过

A:：ONE

或通过

A:：DEFAULTS['ONE']

---

另外，我建议您阅读有关Ruby模块的内容（如果您愿意，可以将它们命名为NameSpec）。这非常重要

您如何访问数组中的值？

A:：ONE

和

A:：TWO

，我认为这有点尴尬。您的问题不清楚。这两个代码段做的事情完全不同。我真的无法想象在哪一种情况下在两者之间做出选择是有意义的。而且，第一个代码是严重混淆的代码，任何编写此类代码的人都应该被解雇。我理解这一点，但我的意思是为了存储键值对。第一个代码段不存储键值对。完全为了存储键值对而比较这两个代码段是毫无意义的，因为其中一个不存储键值对。第一个代码片段只是一种非常模糊的编写

ONE=1的方式；二=2；默认值=[1,2]

。完全同意。感谢您的见解。@JörgWMittag您的“混淆”论点可能是有效的，或者是这个非常简单的例子。但是，该模式可用于实现简单的静态枚举。因此，它一点也不模糊。