题
在 Ruby 中实现枚举习惯用法的最佳方法是什么?我正在寻找一些我可以使用(几乎)像 Java/C# 枚举的东西。
解决方案
两种方式。符号(:foo
符号)或常量(FOO
符号)。
当您想要增强可读性而不用文字字符串乱扔代码时,符号是合适的。
postal_code[:minnesota] = "MN"
postal_code[:new_york] = "NY"
当您具有重要的潜在值时,常量是合适的。只需声明一个模块来保存常量,然后在其中声明常量。
module Foo
BAR = 1
BAZ = 2
BIZ = 4
end
flags = Foo::BAR | Foo::BAZ # flags = 3
其他提示
我很惊讶没有人提供类似以下的东西(从 RAPI 宝石):
class Enum
private
def self.enum_attr(name, num)
name = name.to_s
define_method(name + '?') do
@attrs & num != 0
end
define_method(name + '=') do |set|
if set
@attrs |= num
else
@attrs &= ~num
end
end
end
public
def initialize(attrs = 0)
@attrs = attrs
end
def to_i
@attrs
end
end
可以像这样使用:
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
例子:
>> 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
这在数据库场景中或处理 C 风格常量/枚举时效果很好(就像使用 外国金融机构, ,RAPI 广泛使用)。
此外,您不必担心打字错误会导致静默失败,就像使用哈希类型解决方案一样。
最惯用的方法是使用符号。例如,代替:
enum {
FOO,
BAR,
BAZ
}
myFunc(FOO);
...你可以只使用符号:
# 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)
这比枚举更加开放,但它非常符合 Ruby 精神。
符号也表现得很好。例如,比较两个符号是否相等比比较两个字符串要快得多。
我使用以下方法:
class MyClass
MY_ENUM = [MY_VALUE_1 = 'value1', MY_VALUE_2 = 'value2']
end
我喜欢它有以下优点:
- 它将价值观视觉上分组为一个整体
- 它进行一些编译时检查(与仅使用符号相比)
- 我可以轻松访问所有可能值的列表:只是
MY_ENUM
- 我可以轻松访问不同的值:
MY_VALUE_1
- 它可以有任何类型的值,而不仅仅是 Symbol
符号可能更好,因为如果您在另一个类中使用它,则不必编写外部类的名称(MyClass::MY_VALUE_1
)
如果您使用 Rails 4.2 或更高版本,则可以使用 Rails 枚举。
Rails 现在默认具有枚举,无需包含任何 gem。
这与 Java、C++ 枚举非常相似(并且具有更多功能)。
引自 http://edgeapi.rubyonrails.org/classes/ActiveRecord/Enum.html :
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
这是我在 Ruby 中使用枚举的方法。我想要的是简短而甜蜜的,不一定是最像 C 的。有什么想法吗?
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
"#{self.name} {#{self.constants.join(', ')}}"
end
end
end
end
States = enum %w(Draft Published Trashed)
=> States {Draft, Published, Trashed}
States::Draft
=> 1
States::Published
=> 2
States::Trashed
=> 4
States::Draft | States::Trashed
=> 3
查看 ruby-enum gem, https://github.com/dblock/ruby-enum.
class Gender
include Enum
Gender.define :MALE, "male"
Gender.define :FEMALE, "female"
end
Gender.all
Gender::MALE
我知道这个人已经很久没有发布这个问题了,但我也有同样的问题,而这篇文章没有给我答案。我想要一种简单的方法来查看数字代表什么,轻松比较,最重要的是 ActiveRecord 支持使用代表枚举的列进行查找。
我没有找到任何东西,所以我做了一个很棒的实现,名为 伊努姆 这让我得到了我想要的一切。做了很多规格,所以我很确定它是安全的。
一些示例功能:
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
如果您担心符号拼写错误,请确保您的代码在使用不存在的键访问值时引发异常。您可以通过使用来做到这一点 fetch
而不是 []
:
my_value = my_hash.fetch(:key)
或者,如果您提供不存在的密钥,则默认情况下使散列引发异常:
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
如果哈希已经存在,您可以添加异常引发行为:
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
通常,您不必担心常量的拼写错误安全性。如果常量名称拼写错误,通常会引发异常。
也许最好的轻量级方法是
module MyConstants
ABC = Class.new
DEF = Class.new
GHI = Class.new
end
这样值就有关联的名称,如 Java/C# 中:
MyConstants::ABC
=> MyConstants::ABC
要获得所有值,您可以这样做
MyConstants.constants
=> [:ABC, :DEF, :GHI]
如果你想要一个枚举的序数值,你可以这样做
MyConstants.constants.index :GHI
=> 2
有人继续写了一个红宝石宝石称为 雷纳姆. 。它声称可以获得最接近 Java/C# 的行为。就我个人而言,我仍在学习 Ruby,当我想让一个特定的类包含一个静态枚举(可能是一个散列)时,我有点震惊,因为通过谷歌很难找到它。
这完全取决于您如何使用 Java 或 C# 枚举。您如何使用它将决定您在 Ruby 中选择的解决方案。
尝试一下原生的 Set
类型,例如:
>> 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"}>
符号是 ruby 的方式。然而,有时需要与一些 C 代码或某些东西或 Java 进行交互,这些代码公开了一些用于各种事物的枚举。
#server_roles.rb
module EnumLike
def EnumLike.server_role
server_Symb=[ :SERVER_CLOUD, :SERVER_DESKTOP, :SERVER_WORKSTATION]
server_Enum=Hash.new
i=0
server_Symb.each{ |e| server_Enum[e]=i; i +=1}
return server_Symb,server_Enum
end
end
然后可以像这样使用
require 'server_roles'
sSymb, sEnum =EnumLike.server_role()
foreignvec[sEnum[:SERVER_WORKSTATION]]=8
这当然可以变得抽象,你可以推出我们自己的 Enum 类
我已经实现了这样的枚举
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
那么就很容易进行操作了
EnumType.ENUM_1.label
...
enum = EnumType.find_by_id 1
...
valueArray = EnumType.values
这看起来有点多余,但这是我使用过几次的方法,特别是在我与 xml 或类似的集成时。
#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
这给了我 C# 枚举的严谨性,并且它与模型相关。
另一种解决方案是使用 OpenStruct。它非常直接和干净。
https://ruby-doc.org/stdlib-2.3.1/libdoc/ostruct/rdoc/OpenStruct.html
例子:
# 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'
大多数人使用符号(即 :foo_bar
句法)。它们是一种独特的、不透明的价值观。符号不属于任何枚举类型,因此它们并不是 C 枚举类型的真正忠实表示,但这已经是最好的了。
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
输出:
1 - 一个
2-b
3-c
4天
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)
输出:
GOOD
有时我需要的只是能够获取枚举的值并识别其名称,类似于java世界。
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'
对我来说,这服务于枚举的目的,并使其具有很强的可扩展性。您可以向 Enum 类添加更多方法,并且 viola 在所有定义的枚举中免费获取它们。例如。get_all_names 之类的东西。
另一种方法是使用带有包含名称和值的哈希的 Ruby 类,如下所述 RubyFleebie 博客文章. 。这使您可以轻松地在值和常量之间进行转换(特别是如果您添加类方法来查找给定值的名称)。
我认为实现类似枚举类型的最佳方法是使用符号,因为它们几乎表现为整数(当涉及到性能时,object_id 用于进行比较);你不需要担心索引,它们在你的代码中看起来非常整洁 xD
另一种模仿枚举的方法,具有一致的相等处理(无耻地采用戴夫托马斯)。允许开放枚举(很像符号)和封闭(预定义)枚举。
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 # => true
Genre::Gothic != Architecture::Gothic # => true
尝试一下 inum。https://github.com/alfa-jpn/inum
class Color < Inum::Base
define :RED
define :GREEN
define :BLUE
end
Color::RED
Color.parse('blue') # => Color::BLUE
Color.parse(2) # => Color::GREEN
又快又脏,感觉像 C#:
class FeelsLikeAnEnum
def self.Option_1() :option_1 end
def self.Option_2() :option_2 end
def self.Option_3() :option_3 end
end
像使用枚举一样使用它:
method_that_needs_options(FeelsLikeAnEnum.Option_1)