Ruby 是否有一种智能的方法来检查自定义对象是否在数组中？

假设我有一个自定义类的

arr

实例

myu类

。这个类有两个不同的实例变量。让我们称它们为

：name

（一个字符串），

：正在处理的
（一个布尔值）和
：date
（一个）。它们都是可读的

根据上述实例变量的内容，检查
My_class
（称之为
newbe
）的另一个给定实例是否已在数组中的最佳方法是什么

使用
arr.include？（newbe）
将不起作用，因为这会比较对象ID，不是吗？

我可以重写
Array#include？
比较两个对象的方式吗


用代码说话

class My_class
  attr_reader :name, :is_processed, :date

  def initialize(_name, _proc, _d)
    @name = _name
    @is_processed = _proc
    @date = _d
  end
end

其他地方

first = My_class.new("First", false, DateTime.new(2001,2,3,4,5,6))
second = My_class.new("Second", true, DateTime.new(2001,2,3,4,5,6))
third = My_class.new("Third", false, DateTime.new(2001,2,3,3,2,1))
newbe = My_class.new("Second", true, DateTime.new(2001,2,3,4,5,6))

arr = [first, second, third]
arr.include?(newbe)  # => false but should be true

将
any？
与块一起使用

my_arr.any? { |o| o.kind_of?(MyClass) }

如果要恢复匹配的对象，还可以使用
检测
或
查找
。这些都是
可枚举
上的标准方法，大多数类都会混合使用这些方法。
将
任何？
与块一起使用

my_arr.any? { |o| o.kind_of?(MyClass) }

如果要恢复匹配的对象，还可以使用
检测
或
查找
。这些都是<>代码>枚举的标准方法，大多数集合Is类混合在一起。
 您应该考虑对自定义类重新定义＝=是否有意义，如：

class My_class
  def ==(other)
    (other.is_a? My_class) && 
    (other.name == @name)  &&
    (other.is_processed == @is_processed) &&
    (other.date == @date)
  end
end

如果这样做，数组#包含？将按照您想要的方式工作。
您应该考虑对自定义类重新定义= =是否有意义，例如：
class My_class
  def ==(other)
    (other.is_a? My_class) && 
    (other.name == @name)  &&
    (other.is_processed == @is_processed) &&
    (other.date == @date)
  end
end

如果这样做，数组#包含？将按您希望的方式工作。
如果您希望比较类的实例，请包括
comparable
，定义
方法，并将这些方法添加到类实例中：

=之间？（#包括？使用#=）

需要“日期”
上我的课
包括可比
属性读取器：名称，：是否已处理，：日期
def初始化（_名称，_过程，_d）
@名称=\u名称
@是否已处理=\u过程
@日期=\u d
终止
def（其他）
[self.name，self.is_processed，self.date][other.name，other.is_processed，other.date]
终止
终止
first=My_class.new（“first”，false，DateTime.new（2001,2,3,4,5,6））
second=My_class.new（“second”，true，DateTime.new（2001,2,3,4,5,6））
第三个=我的班级。新建（“第三个”，false，DateTime.new（2001,2,3,3,2,1））
newbe=My_class.new（“Second”，true，DateTime.new（2001,2,3,4,5,6））
arr=[第一、第二、第三]
p arr.include？（newbe）#=>正确
#你可以做arr.sort，但它们被意外地整理好了。。。
您希望比较类的实例，因此包括
comparable
，定义
方法，并将这些方法添加到类实例中：

=之间？（#包括？使用#=）

需要“日期”
上我的课
包括可比
属性读取器：名称，：是否已处理，：日期
def初始化（_名称，_过程，_d）
@名称=\u名称
@是否已处理=\u过程
@日期=\u d
终止
def（其他）
[self.name，self.is_processed，self.date][other.name，other.is_processed，other.date]
终止
终止
first=My_class.new（“first”，false，DateTime.new（2001,2,3,4,5,6））
second=My_class.new（“second”，true，DateTime.new（2001,2,3,4,5,6））
第三个=我的班级。新建（“第三个”，false，DateTime.new（2001,2,3,3,2,1））
newbe=My_class.new（“Second”，true，DateTime.new（2001,2,3,4,5,6））
arr=[第一、第二、第三]
p arr.include？（newbe）#=>正确
#你可以做arr.sort，但它们被意外地整理好了。。。
感谢您的快速回答。就我不想知道匹配项的索引（或匹配多少项的计数）而言，这可能是最好的方法。但是，我应该用
（o.name==newbe.name&&o.is\u processed==newbe.is\u processed&&o.date==newbe.is\u processed&&o.date==newbe.date）替换
。附言：在接受答案之前，我会等待更多的答案。
！my_arr.grep（MyClass）.empty？
也应该可以工作，因为类实现了
=
。不过，对于维护人员来说，这可能是个小小的麻烦。谢谢您的快速回答。就我不想知道匹配项的索引（或匹配多少项的计数）而言，这可能是最好的方法。但是，我应该用
（o.name==newbe.name&&o.is\u processed==newbe.is\u processed&&o.date==newbe.is\u processed&&o.date==newbe.date）替换
。附言：在接受答案之前，我会等待更多的答案。
！my_arr.grep（MyClass）.empty？
也应该可以工作，因为类实现了
=
。不过，对于维护人员来说，这可能是个小小的麻烦。谢谢您的回答。我将实施这种方法，因为我认为它是最通用的方法。谢谢你的回答。我将实施这种方法，因为我认为它是最通用的方法。