在Ruby中实现枚举用法的最佳方法是什么? 我正在寻找可以(几乎)使用的东西,例如Java / C#枚举。

===============>>#1 票数:304 已采纳

两种方式。 符号( :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

===============>>#2 票数:58

我很惊讶没有人提供以下内容(从RAPI gem中获得):

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广泛使用的FFI的情况)时效果很好。

而且,您不必担心像输入错误一样会导致无提示失败,就像使用哈希类型的解决方案一样。

===============>>#3 票数:52

最惯用的方法是使用符号。 例如,代替:

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精神非常契合。

符号的表现也很好。 例如,比较两个符号是否相等,比比较两个字符串要快得多。

===============>>#4 票数:35

我使用以下方法:

class MyClass
  MY_ENUM = [MY_VALUE_1 = 'value1', MY_VALUE_2 = 'value2']
end

我喜欢它具有以下优点:

  1. 视觉上将价值分组为一个整体
  2. 它会进行一些编译时检查(与仅使用符号相反)
  3. 我可以轻松访问所有可能值的列表:仅MY_ENUM
  4. 我可以轻松访问不同的值: MY_VALUE_1
  5. 它可以具有任何类型的值,而不仅仅是Symbol

如果您在另一个类中使用MyClass::MY_VALUE_1MyClass::MY_VALUE_1 ),则符号可能会更好,因为您不必写外部类的名称。

===============>>#5 票数:18

如果您使用的是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

===============>>#6 票数:8

这是我在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

===============>>#7 票数:8

我知道自从这个人发布这个问题已经很久了,但是我有同样的问题,而这个发布并没有给我答案。 我想要一种简单的方法来查看数字表示的内容,进行简单的比较以及使用表示枚举的列进行查找的大多数ActiveRecord支持。

我什么都没找到,所以我做了一个叫yinum的出色实现,它允许我寻找的所有内容。 做了很多规格,所以我很确定它是安全的。

一些示例功能:

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

===============>>#8 票数:8

查看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

===============>>#9 票数:5

也许最好的轻量级方法是

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

===============>>#10 票数:5

如果您担心带有符号的错字,请确保当您使用不存在的键访问值时,代码会引发异常。 您可以使用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

通常,您不必担心常量的错字安全性。 如果您拼写错误的常量名称,通常会引发异常。

===============>>#11 票数:4

有人继续写了一个名为Renum的红宝石。 它声称获得最接近的Java / C#行为。 就我个人而言,我仍在学习Ruby,当我想让特定的类包含静态枚举(可能是哈希)时,我感到有些震惊,因为它不是通过Google完全找到的。

===============>>#12 票数:3

最近,我们发布了一个在Ruby中实现Enumsgem 在我的帖子中,您将找到有关问题的答案。 我还在那里描述了为什么我们的实现比现有的更好(实际上,Ruby中有很多此功能的实现,但它们都是宝石)。

===============>>#13 票数:3

另一个解决方案是使用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'

===============>>#14 票数:3

这完全取决于您如何使用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"}>

===============>>#15 票数:2

这似乎有点多余,但这是我使用过几次的方法,尤其是在我与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

这给我带来了ac#枚举的严谨性,并且与模型紧密相关。

===============>>#16 票数:2

符号是红宝石的方式。 但是,有时需要与一些C代码或某些Java或某些暴露各种事物的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类

===============>>#17 票数:2

我已经实现了这样的枚举

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

===============>>#18 票数:1

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

===============>>#19 票数:1

有时候,我所需要的只是能够获取枚举的值并识别其名称,类似于java world。

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类添加更多方法,中提琴可以在所有定义的枚举中免费获取它们。 例如。 get_all_names之类的东西。

===============>>#20 票数:1

大多数人使用符号(即:foo_bar语法)。 它们是唯一的不透明值。 符号不属于任何枚举样式类型,因此它们实际上并不是C枚举类型的忠实表示,但这几乎是一样好。

===============>>#21 票数:1

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天

===============>>#22 票数:0

模仿具有一致的相等性处理的枚举的另一种方法(从Dave Thomas中无耻地采用)。 允许打开的枚举(很像符号)和关闭的(预定义)枚举。

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

===============>>#23 票数:0

另一种方法是将Ruby类与包含名称和值的哈希一起使用,如以下RubyFleebie博客文章中所述 这使您可以轻松地在值和常量之间转换(尤其是如果您添加类方法以查找给定值的名称时)。

===============>>#24 票数:0

我认为实现像类型这样的枚举的最佳方法是使用符号,因为符号的行为几乎都是整数(当涉及到performace时,使用object_id进行比较); 您无需担心索引编制,它们在您的代码xD中看起来非常整洁

===============>>#25 票数:0

尝试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

查看更多https://github.com/alfa-jpn/inum#usage

===============>>#26 票数:-1

快速又肮脏,感觉就像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)

  ask by auramo translate from so

未解决问题?本站智能推荐:

1回复

您将如何在Ruby中实现此Java枚举类? [重复]

这个问题已经在这里有了答案: 如何在Ruby中实现枚举? 26个答案 我从Java类获得以下代码: 作为Ruby的新手,我试图找出在Ruby中实现的方法。 越简单越好。 我根据这里的一些帖子尝试了以下内容,但似乎无法完成。 我希望该类具有一个pars
1回复

Ruby:如何在一个夹具中配置一个枚举?

给定此类: 我想创建一个看起来像这样的灯具: 我已经尝试了多种语法变体,但是还没有找到可行的方法。 结果user.permission为nil或0。我知道枚举是相对较新的加法。 能做到吗?
3回复

迭代在ruby中的枚举

我有以下具有枚举(UserStatus)的ruby类(user.rd): 有没有办法可以迭代所有枚举值?
2回复

在Ruby on Rails中映射枚举

我正在使用4.2版的Rails API,并且陷入了相关条目的枚举映射中。 我的模特正在关注 在我刚刚检索入学列表时,可以将成绩字段作为枚举值。 但是,当使用带有选择方法的联接查询返回值时,我仅获得了数据库整数值。 我的检索逻辑如下 我的json如下所示: 我需要返回
1回复

Ruby中的枚举并获取字符串值

我的其中一个rails模型中具有以下模块: 我通过执行Color::RED等将这些值作为整数存储在db中。当我取回这些值时,我想获取字符串,即“ red”。 但是我在转换0->“ RED” /“ red”时遇到麻烦。 我想念什么? 我可以使用模块方法来做到这一点,还是有更好的
3回复

Ruby中类似Java的高级枚举

首先,这不是Ruby中枚举的重复:) 该问题的公认答案表明这是在Ruby中表示枚举的一种好方法: 在Java中,可以将多个值和方法附加到枚举值。 我想在Ruby中实现相同或类似的东西。 什么是最类似Ruby的方式来表示这个Java枚举: 编辑: 我还想保留Ja
1回复

Ruby - 枚举文件

在C#中,我习惯于创建一个名为“Enums.cs”的文件,并在那里定义我的应用程序将需要的所有枚举......我认为这样做更容易。 现在接受Ruby,我阅读并选择module方法来定义枚举,因为我可以将int与“单词”相关联,如: 现在,我如何让我的“用户”模型公开一个属性,如newG
2回复

如何从其在ruby-on-rails中的索引中获取枚举值?

例如,我在ruby-on-rails中有这个枚举: class Foo < ActiveRecord::Base enum color: [ :red, :green, :blue ] end 默认情况下,索引应为:red-> 0,:green-> 1,依此类推。
1回复

Ruby:如何为枚举中的第一个常量得到-1的值?

我在我的模型'Payment'中声明了一个枚举,它与数据库中的列不对应。 我可以从enum所在的类中获取枚举的整数值: 这回来了 但是,我希望返回的值以-1开头而不是0开始。 我该如何实现这一目标? 谢谢!
1回复

如何使用此代码中的枚举来限制Ruby中方法参数的选择?

我有以下代码: 这是我从谷歌搜索中使枚举在Ruby中工作的方法,因为没有本机枚举类。 这就是我想要完成的 谢谢,