（Ruby）如何专门为特定比较返回-1

比方说，当我在ruby中比较值时，我心里有一个值，不管我想要什么，对该值使用sort，其他任何值都返回-1（因此该值默认排序为小于所有值）

例如，假设我希望'100'在100%的时间内对99进行较小的排序。因此，如果我对数组中的值进行排序，并且比较结果在100和99之间出现，那么100被排序得更小（即返回-1）。但是，我希望所有其他情况都正常（98比99小，50比30大，等等）

编辑：好的，这就是我想要的

如果我有一个x和一个y，我不想使用

x <=> y

---

也就是说，x总是大于y，为什么不使用字典来保存与其相对值关联的值呢？在这种情况下，字符串abc可以映射到-1，然后确保没有其他值映射到等于或小于-1的值

---

编辑：如果您只关心一个违反规范的特定值，则此解决方案不适合您。

您可以覆盖对象的排序方法，如下所示：

class Fixnum
  alias old_sort <=>

  def <=>(object)
    if (self == 100 or object == 100)
      return -1
    else
      return self.old_sort object
    end
  end
end

puts (101 <=> 100)

class-Fixnum
别名old_排序
def（对象）
if（self==100或object==100）
返回-1
其他的
返回self.old_排序对象
结束
结束
结束
卖出（101 100）

编辑1:以上是一个完全有效的示例

---

编辑2:正如johannes在评论中所说的那样，您真的不应该实现这个精确的代码。这只是一个简单的例子，说明了如何重写排序方法来执行特定于域的逻辑。此外，还更新了代码以反映johannes关于与object和self进行比较的其他评论。

一种方法是为自定义比较实现派生类（）

下面是一些示例代码（和测试）：

class-StrA

以及测试：

a = StrA.new("Z")
b = StrA.new("B")
c = StrA.new("abc")
d = StrA.new("")

a > b # 1
a > c # 1
c > a # -1
d > c # 1
c > d # -1
c < d # 1
c > d # -1

[a, b, c, d].sort! # [ "Z", "B", "", "abc"]

a=StrA.new（“Z”）
b=战略新（“b”）
c=战略新（“abc”）
d=StrA.new（“”）
a>b#1
a>c#1
c>a#-1
d>c#1
c>d#-1
cd#-1
[a，b，c，d].排序[“Z”、“B”、“abc”]

更容易处理分拣之外的特殊性

module Enumerable
  def sort_excluding(*vals)
    special,rest = partition {|x| vals.include?(x)}
    rest.sort + special
  end
end

Array#sort

或

Enumerable#sort

（我不知道您试图排序什么）可以接受一个obtional块。如果给出了块，则块用于比较，而不是

例如，此代码将反向排序：

foo.sort { |a,b| b <=> a }

---

我不能完全确定您尝试排序的方式，但这应该使您能够以需要的方式使用sort。有关

数组#排序

和任何其他方法的更多信息，可以通过

ri

在您的linux（以及可能的其他操作系统）上找到，如下所示：

ri数组#排序

我想您想要的是：

[30, 50, 4, 0, 100, -22, 99].sort_by {|a| [a == 100 ? -1 : 0, a ]}.reverse

其中：

99
50
30
 4
 0
-22
100

---

希望我能理解这个问题

你能把你的问题重新措辞一下吗？你的第一句话没有太多的意义。问清楚的问题大大提高了获得好答案的机会。我认为你不能用字母和符号混合命名方法，即

old\uuu

和

old

是无效的方法名称。@Rapion谢谢，现已修复：-）修补某些现有行为会产生毁灭性影响。你不可能想到所有的功能都依赖于

Fixnum

的正确行为，在ruby中排序时，你永远不知道

100

是

self

还是

object

。你必须考虑这两种可能性。“我不指望他能实现这一点，我意识到FiunNUM的压倒一切的功能是可怕的，我只是想给他一个工作实例，他可以修改以适合自己的需要。只为排序/数组工作。如果他想对对象进行比较，这是行不通的。你需要在

模块Enumerable

中进行比较，而不是在

类数组

中进行比较，

数组

包含

Enumerable

，因此它在

数组

和所有其他包含

Enumerable

的类中都有效。好的一点，改变了。虽然我不确定这在一般实践中是否有多重要。还有什么东西不是数组或者不是数组的子类？将集合和哈希转换为数组进行排序。（即使在哈希保持顺序的1.9版本中！）他只希望100比其他任何东西都小。其余的应该是普通的。你可以用

a==100来做这个？1.0/0:a

。但前提是要排序的元素从不包含负无穷大。

foo.sort do |a,b|
  if [a,b].sort == [99,100]
    b-a # returns 1 or -1 so that 99 > 100
  else
    a <=> b
  end
end

[30, 50, 4, 0, 100, -22, 99].sort_by {|a| [a == 100 ? -1 : 0, a ]}.reverse

99
50
30
 4
 0
-22
100