blocks|key|1546025|text|大多数人使用符号(这是:foo_bar语法)。它们是某种独特的、不透明的值。符号不属于任何枚举类型，所以它们不是C的枚举类型的忠实表示，但这已经足够好了。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1546026|entityMap^0|B|8|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Most people use symbols (that's the <code>:foo_bar</code> syntax). They're sort of unique opaque values. Symbols don't belong to any enum-style type so they're not really a faithful representation of C's enum type but this is pretty much as good as it gets.

blocks|key|1546122|text|最常用的方法是使用符号。例如，而不是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1546123|enum+{
++FOO,
++BAR,
++BAZ
}

myFunc(FOO);|code-block|syntax|javascript|1546124|...you只能使用符号：|1546125|#+You+don't+actually+need+to+declare+these,+of+course--this+is
#+just+to+show+you+what+symbols+look+like.
:foo
:bar
:baz

my_func(:foo)|1546126|这比枚举更具开放性，但它非常符合Ruby精神。|1546127|符号的性能也很好。例如，比较两个符号是否相等要比比较两个字符串快得多。|1546128|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

The most idiomatic way to do this is to use symbols. For example, instead of:

<pre><code>enum {
 FOO,
 BAR,
 BAZ
}

myFunc(FOO);
</code></pre>

...you can just use symbols:

<pre><code># You don't actually need to declare these, of course--this is
# just to show you what symbols look like.
:foo
:bar
:baz

my_func(:foo)
</code></pre>

This is a bit more open-ended than enums, but it fits well with the Ruby spirit.

Symbols also perform very well. Comparing two symbols for equality, for example, is much faster than comparing two strings.

blocks|key|1546181|text|两种方式。符号(:foo表示法)或常量(FOO表示法)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1546182|当您想要增强可读性而又不想在代码中乱丢文字字符串时，符号是合适的。|1546183|postal_code[:minnesota]+=+"MN"
postal_code[:new_york]+=+"NY"|code-block|syntax|javascript|1546184|当您有一个重要的基础值时，常量是合适的。只需声明一个模块来保存您的常量，然后在其中声明常量。|1546185|module+Foo
++BAR+=+1
++BAZ+=+2
++BIZ+=+4
end
+
flags+=+Foo::BAR+%7C+Foo::BAZ+#+flags+=+3|1546186|新增2021-01-17|1546187|如果要传递枚举值(例如，将其存储在数据库中)，并且需要能够将值转换回符号，则这两种方法都有一个混搭|1546188|COMMODITY_TYPE+=+{
++currency:+1,
++investment:+2,
}

def+commodity_type_string(value)
++COMMODITY_TYPE.key(value)
end

COMMODITY_TYPE[:currency]|1546189|这种方法的灵感来自安德鲁-格林的答案https://stackoverflow.com/a/5332950/13468|1546190|我还建议通读这里的其余答案，因为有很多方法可以解决这个问题，这实际上归结为您所关心的另一种语言的枚举是什么|1546191|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/5332950/13468^0|8|4|K|3|0|0|0|0|0|0|0|0|I|15|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1D|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1F|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1G|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1H|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1I|8|@]|D|@]|E|$]]|$1|U|3|V|5|J|7|1J|8|@]|D|@]|E|$K|L]]|$1|W|3|X|5|6|7|1K|8|@]|D|@$9|1L|A|1M|1|1N]]|E|$]]|$1|Y|3|Z|5|6|7|1O|8|@]|D|@]|E|$]]|$1|10|3|-4|5|6|7|1P|8|@]|D|@]|E|$]]]|11|$12|$5|13|14|15|E|$16|17]]]]

Two ways. Symbols (<code>:foo</code> notation) or constants (<code>FOO</code> notation).
Symbols are appropriate when you want to enhance readability without littering code with literal strings.
<pre><code>postal_code[:minnesota] = &quot;MN&quot;
postal_code[:new_york] = &quot;NY&quot;
</code></pre>
Constants are appropriate when you have an underlying value that is important. Just declare a module to hold your constants and then declare the constants within that.
<pre><code>module Foo
 BAR = 1
 BAZ = 2
 BIZ = 4
end
 
flags = Foo::BAR | Foo::BAZ # flags = 3
</code></pre>
Added 2021-01-17
If you are passing the enum value around (for example, storing it in a database) and you need to be able to translate the value back into the symbol, there's a mashup of both approaches
<pre><code>COMMODITY_TYPE = {
 currency: 1,
 investment: 2,
}

def commodity_type_string(value)
 COMMODITY_TYPE.key(value)
end

COMMODITY_TYPE[:currency]
</code></pre>
This approach inspired by andrew-grimm's answer <a href="https://stackoverflow.com/a/5332950/13468">https://stackoverflow.com/a/5332950/13468</a>
I'd also recommend reading through the rest of the answers here since there are a lot of ways to solve this and it really boils down to what it is about the other language's enum that you care about

blocks|key|1761080|text|这完全取决于您如何使用Java或C#枚举。如何使用它将决定您在Ruby中选择的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1761081|尝试原生Set类型，例如：|offset|length|style|CODE|1761082|>>+enum+=+Set['a',+'b',+'c']
=>+#<Set:+{"a",+"b",+"c"}>
>>+enum.member?+"b"
=>+true
>>+enum.member?+"d"
=>+false
>>+enum.add?+"b"
=>+nil
>>+enum.add?+"d"
=>+#<Set:+{"a",+"b",+"c",+"d"}>|code-block|syntax|javascript|1761083|entityMap^0|0|4|3|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

It all depends how you use Java or C# enums. How you use it will dictate the solution you'll choose in Ruby.

Try the native <code>Set</code> type, for instance:

<pre><code>&gt;&gt; enum = Set['a', 'b', 'c']
=&gt; #&lt;Set: {"a", "b", "c"}&gt;
&gt;&gt; enum.member? "b"
=&gt; true
&gt;&gt; enum.member? "d"
=&gt; false
&gt;&gt; enum.add? "b"
=&gt; nil
&gt;&gt; enum.add? "d"
=&gt; #&lt;Set: {"a", "b", "c", "d"}&gt;
</code></pre>

blocks|key|1546282|text|有人继续写了一个名为Renum的宝石。它声称获得了最接近Java/C#的行为。就我个人而言，我仍然在学习Ruby，当我想让一个特定的类包含一个静态枚举时，我感到有点震惊，可能是一个哈希，而这并不是很容易通过google找到的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1546283|entityMap|0|LINK|mutability|MUTABLE|url|http://renum.rubyforge.org/^0|A|5|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Someone went ahead and wrote a ruby gem called <a href="http://renum.rubyforge.org/" rel="nofollow noreferrer">Renum</a>. It claims to get the closest Java/C# like behavior. Personally I'm still learning Ruby, and I was a little shocked when I wanted to make a specific class contain a static enum, possibly a hash, that it wasn't exactly easily found via google.

blocks|key|1761182|text|另一种方法是使用带有散列的Ruby类，该散列包含名称和值，如以下RubyFleebie+blog+post所述。这使您可以轻松地在值和常量之间进行转换(特别是当您添加一个类方法来查找给定值的名称时)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1761183|entityMap|0|LINK|mutability|MUTABLE|url|http://www.rubyfleebie.com/enumerations-and-ruby/^0|W|L|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Another approach is to use a Ruby class with a hash containing names and values as described in the following <a href="http://www.rubyfleebie.com/enumerations-and-ruby/" rel="nofollow noreferrer">RubyFleebie blog post</a>. This allows you to convert easily between values and constants (especially if you add a class method to lookup the name for a given value).

blocks|key|1546411|text|我认为实现与类型类似的枚举的最好方法是使用符号，因为符号的行为相当于整数(当涉及到性能时，object_id用于进行比较)；您不需要担心索引，并且它们在代码xD中看起来非常整洁|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1546412|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I think the best way to implement enumeration like types is with symbols since the pretty much behave as integer (when it comes to performace, object_id is used to make comparisons ); you don't need to worry about indexing and they look really neat in your code xD

blocks|key|1761283|text|看看ruby-enum+gem，https://github.com/dblock/ruby-enum。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1761284|class+Gender
++include+Enum

++Gender.define+:MALE,+"male"
++Gender.define+:FEMALE,+"female"
end

Gender.all
Gender::MALE|code-block|syntax|javascript|1761285|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/dblock/ruby-enum^0|G|Z|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Check out the ruby-enum gem, <a href="https://github.com/dblock/ruby-enum" rel="noreferrer">https://github.com/dblock/ruby-enum</a>.

<pre><code>class Gender
 include Enum

 Gender.define :MALE, "male"
 Gender.define :FEMALE, "female"
end

Gender.all
Gender::MALE
</code></pre>

blocks|key|1761363|text|如果您担心符号的拼写错误，请确保您的代码在访问带有不存在的键的值时引发异常。您可以使用fetch而不是[]来完成此操作|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1761364|my_value+=+my_hash.fetch(:key)|code-block|syntax|javascript|1761365|或者，如果您提供了一个不存在的键，则默认情况下使散列引发异常：|1761366|my_hash+=+Hash.new+do+%7Chash,+key%7C
++raise+"You+tried+to+access+using+#{key.inspect}+when+the+only+keys+we+have+are+#{hash.keys.inspect}"
end|1761367|如果散列已经存在，您可以添加异常引发行为：|1761368|my_hash+=+Hash[[[1,2]]]
my_hash.default_proc+=+proc+do+%7Chash,+key%7C
++raise+"You+tried+to+access+using+#{key.inspect}+when+the+only+keys+we+have+are+#{hash.keys.inspect}"
end|1761369|通常，您不必担心常量的输入安全问题。如果您拼写错误的常量名称，它通常会引发异常。|1761370|entityMap^0|17|5|1F|2|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|16|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|V|$]]

If you're worried about typos with symbols, make sure your code raises an exception when you access a value with a non-existent key. You can do this by using <code>fetch</code> rather than <code>[]</code>:

<pre><code>my_value = my_hash.fetch(:key)
</code></pre>

or by making the hash raise an exception by default if you supply a non-existent key:

<pre><code>my_hash = Hash.new do |hash, key|
 raise "You tried to access using #{key.inspect} when the only keys we have are #{hash.keys.inspect}"
end
</code></pre>

If the hash already exists, you can add on exception-raising behaviour:

<pre><code>my_hash = Hash[[[1,2]]]
my_hash.default_proc = proc do |hash, key|
 raise "You tried to access using #{key.inspect} when the only keys we have are #{hash.keys.inspect}"
end
</code></pre>

Normally, you don't have to worry about typo safety with constants. If you misspell a constant name, it'll usually raise an exception.

blocks|key|1761432|text|令我惊讶的是，没有人提供这样的东西(从RAPI+gem中收获)：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1761433|class+Enum

++private

++def+self.enum_attr(name,+num)
++++name+=+name.to_s

++++define_method(name+%2B+'?')+do
++++++@attrs+&+num+!=+0
++++end

++++define_method(name+%2B+'=')+do+%7Cset%7C
++++++if+set
++++++++@attrs+%7C=+num
++++++else
++++++++@attrs+&=+~num
++++++end
++++end
++end

++public

++def+initialize(attrs+=+0)
++++@attrs+=+attrs
++end

++def+to_i
++++@attrs
++end
end|code-block|syntax|javascript|1761434|它可以像这样使用：|1761435|class+FileAttributes+<+Enum
++enum_attr+:readonly,+++++++0x0001
++enum_attr+:hidden,+++++++++0x0002
++enum_attr+:system,+++++++++0x0004
++enum_attr+:directory,++++++0x0010
++enum_attr+:archive,++++++++0x0020
++enum_attr+:in_rom,+++++++++0x0040
++enum_attr+:normal,+++++++++0x0080
++enum_attr+:temporary,++++++0x0100
++enum_attr+:sparse,+++++++++0x0200
++enum_attr+:reparse_point,++0x0400
++enum_attr+:compressed,+++++0x0800
++enum_attr+:rom_module,+++++0x2000
end|1761436|示例：|1761437|>>+example+=+FileAttributes.new(3)
=>+#<FileAttributes:0x629d90+@attrs=3>
>>+example.readonly?
=>+true
>>+example.hidden?
=>+true
>>+example.system?
=>+false
>>+example.system+=+true
=>+true
>>+example.system?
=>+true
>>+example.to_i
=>+7|1761438|在数据库场景中，或者在处理C风格的常量/枚举时(就像使用FFI时一样，RAPI被广泛使用)，这一点发挥得很好。|1761439|而且，您不必像使用散列类型的解决方案那样担心输入错误会导致静默失败。|1761440|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/cstrahan/rapi/blob/master/lib/rapi.rb|1|https://github.com/ffi/ffi/^0|J|4|0|0|0|0|0|0|0|S|3|1|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|D|3|E|5|F|7|18|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|19|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|1A|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|1B|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|1C|8|@]|9|@]|C|$G|H]]|$1|Q|3|R|5|6|7|1D|8|@]|9|@$A|1E|B|1F|1|1G]]|C|$]]|$1|S|3|T|5|6|7|1H|8|@]|9|@]|C|$]]|$1|U|3|-4|5|6|7|1I|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]|12|$5|X|Y|Z|C|$10|13]]]]

I'm surprised that no one has offered something like the following (harvested from the <a href="https://github.com/cstrahan/rapi/blob/master/lib/rapi.rb" rel="noreferrer">RAPI</a> gem):

<pre><code>class Enum

 private

 def self.enum_attr(name, num)
 name = name.to_s

 define_method(name + '?') do
 @attrs &amp; num != 0
 end

 define_method(name + '=') do |set|
 if set
 @attrs |= num
 else
 @attrs &amp;= ~num
 end
 end
 end

 public

 def initialize(attrs = 0)
 @attrs = attrs
 end

 def to_i
 @attrs
 end
end
</code></pre>

Which can be used like so:

<pre><code>class FileAttributes &lt; Enum
 enum_attr :readonly, 0x0001
 enum_attr :hidden, 0x0002
 enum_attr :system, 0x0004
 enum_attr :directory, 0x0010
 enum_attr :archive, 0x0020
 enum_attr :in_rom, 0x0040
 enum_attr :normal, 0x0080
 enum_attr :temporary, 0x0100
 enum_attr :sparse, 0x0200
 enum_attr :reparse_point, 0x0400
 enum_attr :compressed, 0x0800
 enum_attr :rom_module, 0x2000
end
</code></pre>

Example:

<pre><code>&gt;&gt; example = FileAttributes.new(3)
=&gt; #&lt;FileAttributes:0x629d90 @attrs=3&gt;
&gt;&gt; example.readonly?
=&gt; true
&gt;&gt; example.hidden?
=&gt; true
&gt;&gt; example.system?
=&gt; false
&gt;&gt; example.system = true
=&gt; true
&gt;&gt; example.system?
=&gt; true
&gt;&gt; example.to_i
=&gt; 7
</code></pre>

This plays well in database scenarios, or when dealing with C style constants/enums (as is the case when using <a href="https://github.com/ffi/ffi/" rel="noreferrer">FFI</a>, which RAPI makes extensive use of).

Also, you don't have to worry about typos causing silent failures, as you would with using a hash-type solution.

blocks|key|1761511|text|我已经实现了这样的枚举。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1761512|module+EnumType

++def+self.find_by_id+id
++++if+id.instance_of?+String
++++++id+=+id.to_i
++++end+
++++values.each+do+%7Ctype%7C
++++++if+id+==+type.id
++++++++return+type
++++++end
++++end
++++nil
++end

++def+self.values
++++[@ENUM_1,+@ENUM_2]+
++end

++class+Enum
++++attr_reader+:id,+:label

++++def+initialize+id,+label
++++++@id+=+id
++++++@label+=+label
++++end
++end

++@ENUM_1+=+Enum.new(1,+"first")
++@ENUM_2+=+Enum.new(2,+"second")

end|code-block|syntax|javascript|1761513|然后它就很容易进行操作了|1761514|EnumType.ENUM_1.label|1761515|..。|1761516|enum+=+EnumType.find_by_id+1|1761517|1761518|valueArray+=+EnumType.values|1761519|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|V|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|W|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|X|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|O|3|L|5|6|7|Z|8|@]|9|@]|A|$]]|$1|P|3|Q|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|R|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|S|$]]

I have implemented enums like that 

<pre><code>module EnumType

 def self.find_by_id id
 if id.instance_of? String
 id = id.to_i
 end 
 values.each do |type|
 if id == type.id
 return type
 end
 end
 nil
 end

 def self.values
 [@ENUM_1, @ENUM_2] 
 end

 class Enum
 attr_reader :id, :label

 def initialize id, label
 @id = id
 @label = label
 end
 end

 @ENUM_1 = Enum.new(1, "first")
 @ENUM_2 = Enum.new(2, "second")

end
</code></pre>

then its easy to do operations 

<pre><code>EnumType.ENUM_1.label
</code></pre>

...

<pre><code>enum = EnumType.find_by_id 1
</code></pre>

...

<pre><code>valueArray = EnumType.values
</code></pre>

blocks|key|1546720|text|irb(main):016:0>+num=[1,2,3,4]
irb(main):017:0>+alph=['a','b','c','d']
irb(main):018:0>+l_enum=alph.to_enum
irb(main):019:0>+s_enum=num.to_enum
irb(main):020:0>+loop+do
irb(main):021:1*+puts+"#{s_enum.next}+-+#{l_enum.next}"
irb(main):022:1>+end|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1546721|输出：|unstyled|1546722|1-a|1546723|2-b|1546724|3-c|1546725|4-d|1546726|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|F|7|W|8|@]|9|@]|A|$]]]|P|$]]

<pre><code>irb(main):016:0&gt; num=[1,2,3,4]
irb(main):017:0&gt; alph=['a','b','c','d']
irb(main):018:0&gt; l_enum=alph.to_enum
irb(main):019:0&gt; s_enum=num.to_enum
irb(main):020:0&gt; loop do
irb(main):021:1* puts "#{s_enum.next} - #{l_enum.next}"
irb(main):022:1&gt; end
</code></pre>

Output:

1 - a 
2 - b 
3 - c 
4 - d

blocks|key|1546745|text|module+Status
++BAD++=+13
++GOOD+=+24

++def+self.to_str(status)
++++for+sym+in+self.constants
++++++if+self.const_get(sym)+==+status
++++++++return+sym.to_s
++++++end
++++end
++end

end


mystatus+=+Status::GOOD

puts+Status::to_str(mystatus)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1546746|输出：|unstyled|1546747|GOOD|1546748|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>module Status
 BAD = 13
 GOOD = 24

 def self.to_str(status)
 for sym in self.constants
 if self.const_get(sym) == status
 return sym.to_s
 end
 end
 end

end


mystatus = Status::GOOD

puts Status::to_str(mystatus)
</code></pre>

Output:

<pre><code>GOOD
</code></pre>

blocks|key|1761619|text|这是我在Ruby中处理枚举的方法。我只是追求简短和甜蜜，不一定是最像C语言的。有什么想法吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1761620|module+Kernel
++def+enum(values)
++++Module.new+do+%7Cmod%7C
++++++values.each_with_index{+%7Cv,i%7C+mod.const_set(v.to_s.capitalize,+2**i)+}

++++++def+mod.inspect
++++++++"#{self.name}+{#{self.constants.join(',+')}}"
++++++end
++++end
++end
end

States+=+enum+%25w(Draft+Published+Trashed)
=>+States+{Draft,+Published,+Trashed}+

States::Draft
=>+1

States::Published
=>+2

States::Trashed
=>+4

States::Draft+%7C+States::Trashed
=>+5|code-block|syntax|javascript|1761621|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is my approach to enums in Ruby. I was going for short and sweet, not necessarily the the most C-like. Any thoughts?
<pre><code>module Kernel
 def enum(values)
 Module.new do |mod|
 values.each_with_index{ |v,i| mod.const_set(v.to_s.capitalize, 2**i) }

 def mod.inspect
 &quot;#{self.name} {#{self.constants.join(', ')}}&quot;
 end
 end
 end
end

States = enum %w(Draft Published Trashed)
=&gt; States {Draft, Published, Trashed} 

States::Draft
=&gt; 1

States::Published
=&gt; 2

States::Trashed
=&gt; 4

States::Draft | States::Trashed
=&gt; 5
</code></pre>

blocks|key|1546864|text|我知道自从那个家伙发布这个问题已经很久了，但我也有同样的问题，这篇文章没有给我答案。我想要一种简单的方法来查看数字代表什么，易于比较，并且最重要的是，ActiveRecord支持使用表示枚举的列进行查找。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1546865|我没有找到任何东西，所以我做了一个很棒的实现，叫做yinum，它允许我寻找的所有东西。做了很多规格，所以我很确定它是安全的。|offset|length|1546866|以下是一些示例功能：|1546867|COLORS+=+Enum.new(:COLORS,+:red+=>+1,+:green+=>+2,+:blue+=>+3)
=>+COLORS(:red+=>+1,+:green+=>+2,+:blue+=>+3)
COLORS.red+==+1+&&+COLORS.red+==+:red
=>+true

class+Car+<+ActiveRecord::Base++++
++attr_enum+:color,+:COLORS,+:red+=>+1,+:black+=>+2
end
car+=+Car.new
car.color+=+:red+/+"red"+/+1+/+"1"
car.color
=>+Car::COLORS.red
car.color.black?
=>+false
Car.red.to_sql
=>+"SELECT+`cars`.*+FROM+`cars`+WHERE+`cars`.`color`+=+1"
Car.last.red?
=>+true|code-block|syntax|javascript|1546868|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/toplex/enum^0|0|P|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@$D|W|E|X|1|Y]]|A|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

I know it's been a long time since the guy posted this question, but I had the same question and this post didn't give me the answer. I wanted an easy way to see what the number represents, easy comparison, and most of all ActiveRecord support for lookup using the column representing the enum.

I didn't find anything, so I made an awesome implementation called <a href="https://github.com/toplex/enum" rel="nofollow noreferrer">yinum</a> which allowed everything I was looking for. Made ton of specs, so I'm pretty sure it's safe.

Some example features:

<pre><code>COLORS = Enum.new(:COLORS, :red =&gt; 1, :green =&gt; 2, :blue =&gt; 3)
=&gt; COLORS(:red =&gt; 1, :green =&gt; 2, :blue =&gt; 3)
COLORS.red == 1 &amp;&amp; COLORS.red == :red
=&gt; true

class Car &lt; ActiveRecord::Base 
 attr_enum :color, :COLORS, :red =&gt; 1, :black =&gt; 2
end
car = Car.new
car.color = :red / "red" / 1 / "1"
car.color
=&gt; Car::COLORS.red
car.color.black?
=&gt; false
Car.red.to_sql
=&gt; "SELECT `cars`.* FROM `cars` WHERE `cars`.`color` = 1"
Car.last.red?
=&gt; true
</code></pre>

blocks|key|1761784|text|另一种使用一致的相等处理来模仿枚举的方法(不知羞耻地从Dave+Thomas那里采用)。允许打开枚举(与符号非常相似)和关闭(预定义)枚举。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1761785|class+Enum
++def+self.new(values+=+nil)
++++enum+=+Class.new+do
++++++unless+values
++++++++def+self.const_missing(name)
++++++++++const_set(name,+new(name))
++++++++end
++++++end

++++++def+initialize(name)
++++++++@enum_name+=+name
++++++end

++++++def+to_s
++++++++"#{self.class}::#@enum_name"
++++++end
++++end

++++if+values
++++++enum.instance_eval+do
++++++++values.each+{+%7Ce%7C+const_set(e,+enum.new(e))+}
++++++end
++++end

++++enum
++end
end

Genre+=+Enum.new+%25w(Gothic+Metal)+#+creates+closed+enum
Architecture+=+Enum.new+++++++++++#+creates+open+enum

Genre::Gothic+==+Genre::Gothic++++++++#+=>+true
Genre::Gothic+!=+Architecture::Gothic+#+=>+true|code-block|syntax|javascript|1761786|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another way to mimic an enum with consistent equality handling (shamelessly adopted from Dave Thomas). Allows open enums (much like symbols) and closed (predefined) enums.

<pre><code>class Enum
 def self.new(values = nil)
 enum = Class.new do
 unless values
 def self.const_missing(name)
 const_set(name, new(name))
 end
 end

 def initialize(name)
 @enum_name = name
 end

 def to_s
 "#{self.class}::#@enum_name"
 end
 end

 if values
 enum.instance_eval do
 values.each { |e| const_set(e, enum.new(e)) }
 end
 end

 enum
 end
end

Genre = Enum.new %w(Gothic Metal) # creates closed enum
Architecture = Enum.new # creates open enum

Genre::Gothic == Genre::Gothic # =&gt; true
Genre::Gothic != Architecture::Gothic # =&gt; true
</code></pre>

blocks|key|1546993|text|这看起来有点多余，但这是一种我已经使用过几次的方法，特别是在我与xml或类似的东西集成时。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1546994|#model
class+Profession
++def+self.pro_enum
++++{:BAKER+=>+0,+
+++++:MANAGER+=>+1,+
+++++:FIREMAN+=>+2,+
+++++:DEV+=>+3,+
+++++:VAL+=>+["BAKER",+"MANAGER",+"FIREMAN",+"DEV"]
++++}
++end
end

Profession.pro_enum[:DEV]++++++#=>3
Profession.pro_enum[:VAL][1]+++#=>MANAGER|code-block|syntax|javascript|1546995|这赋予了我c#枚举的严格性，并且它与模型绑定在一起。|1546996|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

This seems a bit superfluous, but this is a methodology that I have used a few times, especially where I am integrating with xml or some such.

<pre><code>#model
class Profession
 def self.pro_enum
 {:BAKER =&gt; 0, 
 :MANAGER =&gt; 1, 
 :FIREMAN =&gt; 2, 
 :DEV =&gt; 3, 
 :VAL =&gt; ["BAKER", "MANAGER", "FIREMAN", "DEV"]
 }
 end
end

Profession.pro_enum[:DEV] #=&gt;3
Profession.pro_enum[:VAL][1] #=&gt;MANAGER
</code></pre>

This gives me the rigor of a c# enum and it is tied to the model.

blocks|key|1761959|text|如果您使用的是Rails+4.2或更高版本，则可以使用Rails枚举。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1761960|Rails现在默认有枚举，不需要包含任何gem。|1761961|这与Java、C%2B%2B枚举非常相似(功能更多)。|1761962|引用自http://edgeapi.rubyonrails.org/classes/ActiveRecord/Enum.html：|offset|length|1761963|class+Conversation+<+ActiveRecord::Base
++enum+status:+[+:active,+:archived+]
end

#+conversation.update!+status:+0
conversation.active!
conversation.active?+#+=>+true
conversation.status++#+=>+"active"

#+conversation.update!+status:+1
conversation.archived!
conversation.archived?+#+=>+true
conversation.status++++#+=>+"archived"

#+conversation.update!+status:+1
conversation.status+=+"archived"

#+conversation.update!+status:+nil
conversation.status+=+nil
conversation.status.nil?+#+=>+true
conversation.status++++++#+=>+nil|code-block|syntax|javascript|1761964|entityMap|0|LINK|mutability|MUTABLE|url|http://edgeapi.rubyonrails.org/classes/ActiveRecord/Enum.html^0|0|0|0|3|1P|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@$H|10|I|11|1|12]]|A|$]]|$1|J|3|K|5|L|7|13|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

If you are using Rails 4.2 or greater you can use Rails enums.

Rails now has enums by default without the need for including any gems.

This is very similar (and more with features) to Java, C++ enums.

Quoted from <a href="http://edgeapi.rubyonrails.org/classes/ActiveRecord/Enum.html" rel="noreferrer">http://edgeapi.rubyonrails.org/classes/ActiveRecord/Enum.html</a> :

<pre><code>class Conversation &lt; ActiveRecord::Base
 enum status: [ :active, :archived ]
end

# conversation.update! status: 0
conversation.active!
conversation.active? # =&gt; true
conversation.status # =&gt; "active"

# conversation.update! status: 1
conversation.archived!
conversation.archived? # =&gt; true
conversation.status # =&gt; "archived"

# conversation.update! status: 1
conversation.status = "archived"

# conversation.update! status: nil
conversation.status = nil
conversation.status.nil? # =&gt; true
conversation.status # =&gt; nil
</code></pre>

blocks|key|1547159|text|也许最好的轻量级方法是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1547160|module+MyConstants
++ABC+=+Class.new
++DEF+=+Class.new
++GHI+=+Class.new
end|code-block|syntax|javascript|1547161|这样，值就有了相关的名称，如Java/C#：|1547162|MyConstants::ABC
=>+MyConstants::ABC|1547163|要获取所有值，您可以这样做|1547164|MyConstants.constants
=>+[:ABC,+:DEF,+:GHI]+|1547165|如果你需要一个枚举的序数值，你可以这样做|1547166|MyConstants.constants.index+:GHI
=>+2|1547167|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Perhaps the best lightweight approach would be

<pre><code>module MyConstants
 ABC = Class.new
 DEF = Class.new
 GHI = Class.new
end
</code></pre>

This way values have associated names, as in Java/C#:

<pre><code>MyConstants::ABC
=&gt; MyConstants::ABC
</code></pre>

To get all values, you can do

<pre><code>MyConstants.constants
=&gt; [:ABC, :DEF, :GHI] 
</code></pre>

If you want an enum's ordinal value, you can do

<pre><code>MyConstants.constants.index :GHI
=&gt; 2
</code></pre>

blocks|key|1547236|text|有时，我所需要的就是能够获取enum的值并识别它的名称，类似于java+world。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1547237|module+Enum
+++++def+get_value(str)
+++++++const_get(str)
+++++end
+++++def+get_name(sym)
+++++++sym.to_s.upcase
+++++end
+end

+class+Fruits
+++include+Enum
+++APPLE+=+"Delicious"
+++MANGO+=+"Sweet"
+end

+Fruits.get_value('APPLE')+#'Delicious'
+Fruits.get_value('MANGO')+#+'Sweet'

+Fruits.get_name(:apple)+#+'APPLE'
+Fruits.get_name(:mango)+#+'MANGO'|code-block|syntax|javascript|1547238|对我来说，这服务于枚举的目的，并使其具有很好的可扩展性。您可以将更多方法添加到Enum类中，并在所有已定义的枚举中免费获取这些方法。例如。get_all_names之类的东西。|1547239|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Sometimes all I need is to be able to fetch enum's value and identify its name similar to java world.

<pre><code>module Enum
 def get_value(str)
 const_get(str)
 end
 def get_name(sym)
 sym.to_s.upcase
 end
 end

 class Fruits
 include Enum
 APPLE = "Delicious"
 MANGO = "Sweet"
 end

 Fruits.get_value('APPLE') #'Delicious'
 Fruits.get_value('MANGO') # 'Sweet'

 Fruits.get_name(:apple) # 'APPLE'
 Fruits.get_name(:mango) # 'MANGO'
</code></pre>

This to me serves the purpose of enum and keeps it very extensible too. You can add more methods to the Enum class and viola get them for free in all the defined enums. for example. get_all_names and stuff like that.

blocks|key|1762166|text|另一种解决方案是使用OpenStruct。这是非常直接和干净的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1762167|https://ruby-doc.org/stdlib-2.3.1/libdoc/ostruct/rdoc/OpenStruct.html|offset|length|1762168|示例：|1762169|#+bar.rb
require+'ostruct'+#+not+needed+when+using+Rails

#+by+patching+Array+you+have+a+simple+way+of+creating+a+ENUM-style
class+Array
+++def+to_enum(base=0)
++++++OpenStruct.new(map.with_index(base).to_h)
+++end
end

class+Bar

++++MY_ENUM+=+OpenStruct.new(ONE:+1,+TWO:+2,+THREE:+3)
++++MY_ENUM2+=+%25w[ONE+TWO+THREE].to_enum

++++def+use_enum+(value)
++++++++case+value
++++++++when+MY_ENUM.ONE
++++++++++++puts+"Hello,+this+is+ENUM+1"
++++++++when+MY_ENUM.TWO
++++++++++++puts+"Hello,+this+is+ENUM+2"
++++++++when+MY_ENUM.THREE
++++++++++++puts+"Hello,+this+is+ENUM+3"
++++++++else
++++++++++++puts+"#{value}+not+found+in+ENUM"
++++++++end
++++end

end

#+usage
foo+=+Bar.new++++
foo.use_enum+1
foo.use_enum+2
foo.use_enum+9


#+put+this+code+in+a+file+'bar.rb',+start+IRB+and+type:+load+'bar.rb'|code-block|syntax|javascript|1762170|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1X|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@$D|V|E|W|1|X]]|A|$]]|$1|F|3|G|5|6|7|Y|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|Z|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|C]]]]

Another solution is using OpenStruct. Its pretty straight forward and clean.

<a href="https://ruby-doc.org/stdlib-2.3.1/libdoc/ostruct/rdoc/OpenStruct.html" rel="nofollow noreferrer">https://ruby-doc.org/stdlib-2.3.1/libdoc/ostruct/rdoc/OpenStruct.html</a>

Example:

<pre><code># bar.rb
require 'ostruct' # not needed when using Rails

# by patching Array you have a simple way of creating a ENUM-style
class Array
 def to_enum(base=0)
 OpenStruct.new(map.with_index(base).to_h)
 end
end

class Bar

 MY_ENUM = OpenStruct.new(ONE: 1, TWO: 2, THREE: 3)
 MY_ENUM2 = %w[ONE TWO THREE].to_enum

 def use_enum (value)
 case value
 when MY_ENUM.ONE
 puts "Hello, this is ENUM 1"
 when MY_ENUM.TWO
 puts "Hello, this is ENUM 2"
 when MY_ENUM.THREE
 puts "Hello, this is ENUM 3"
 else
 puts "#{value} not found in ENUM"
 end
 end

end

# usage
foo = Bar.new 
foo.use_enum 1
foo.use_enum 2
foo.use_enum 9


# put this code in a file 'bar.rb', start IRB and type: load 'bar.rb'
</code></pre>

blocks|key|1547285|text|尝试使用inum。https://github.com/alfa-jpn/inum|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1547286|class+Color+<+Inum::Base
++define+:RED
++define+:GREEN
++define+:BLUE
end|code-block|syntax|javascript|1547287|Color::RED+
Color.parse('blue')+#+=>+Color::BLUE
Color.parse(2)++++++#+=>+Color::GREEN|1547288|查看更多https://github.com/alfa-jpn/inum#usage|1547289|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/alfa-jpn/inum|1|https://github.com/alfa-jpn/inum#usage^0|9|W|0|0|0|0|4|12|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|F|7|11|8|@]|9|@]|C|$G|H]]|$1|K|3|L|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

Try the inum.
<a href="https://github.com/alfa-jpn/inum" rel="nofollow noreferrer">https://github.com/alfa-jpn/inum</a>

<pre class="lang-js prettyprint-override"><code>class Color &lt; Inum::Base
 define :RED
 define :GREEN
 define :BLUE
end
</code></pre>

<pre class="lang-js prettyprint-override"><code>Color::RED 
Color.parse('blue') # =&gt; Color::BLUE
Color.parse(2) # =&gt; Color::GREEN
</code></pre>

see more <a href="https://github.com/alfa-jpn/inum#usage" rel="nofollow noreferrer">https://github.com/alfa-jpn/inum#usage</a>

What's the best way to implement the enum idiom in Ruby? I'm looking for something which I can use (almost) like the Java/C# enums.

How to implement Enums in Ruby?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在Ruby中实现枚举习惯用法的最佳方式是什么？我正在寻找一些我可以(几乎)使用的东西，比如Java/C#枚举。

问如何在Ruby中实现枚举？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Ruby中实现枚举？EN