Ruby中多条件惯用惰性排序的最优实现方案问询

一、最常用的多条件排序：sort_by #

在Ruby里，多条件排序最顺手的方式就是用sort_by——你只需要在块里返回一个按优先级从高到低排列的条件值数组就行。比如这个经典示例：

Dir["*"].sort_by { |f| [test(?s, f) || 0, test(?M, f), f] }

它会先按文件大小升序排序，大小相同的再按修改时间排序，最后按文件名排序。这种方式借助了Schwartzian变换，每个文件的属性只计算一次，效率挺高，但有个明显局限：它不是真正的惰性求值——哪怕所有文件的大小都不一样，后面的修改时间和文件名还是会被全部计算出来。如果第二个条件是像统计大文件里字符串出现次数这种高成本操作，那这就太浪费资源了。

二、避坑：Wikibooks里的Perl风格实现不适合Ruby #

之前Wikibooks里有个参考Perl写法的Schwartzian变换实现：

sorted_files = Dir["*"].
  collect{|f| [f, test(?s, f), test(?M, f)]}.
  sort {|a, b|
    a[1] <=> b[1] or
    b[2] <=> a[2] or
    a[0] <=> b[0]
  }.collect{|a| a[0]}

但这里有个致命的坑：Perl里0 or $foo会返回$foo，但Ruby里0 or foo会返回0——因为在Ruby里，只有nil和false才是假值，0是真值！这就导致这个排序只会按第一个条件（文件大小）来，后面的修改时间和文件名完全被忽略了，根本达不到多条件排序的效果。

三、Ruby里组合<=>的惯用姿势 #

要正确组合多个太空船运算符（<=>）的结果，核心逻辑是：只有当前一个比较的结果是0（即两个元素在该条件下相等），才继续下一个条件的比较。

在Ruby里，我们可以用nonzero?配合||来实现：

sort { |a, b|
  # 先比较大小，结果非零就直接返回，否则继续比较修改时间
  (test(?s, a) <=> test(?s, b)).nonzero? || 
  # 修改时间降序，结果非零直接返回，否则比较文件名
  (test(?M, b) <=> test(?M, a)).nonzero? || 
  # 最后比较文件名
  a <=> b
}

nonzero?方法会在结果是-1或1的时候返回自身，是0的时候返回nil，而||只有左边是nil或false时才会执行右边的表达式，刚好符合我们的需求。

如果你的Ruby版本在2.6以上，也可以用then方法让逻辑更清晰：

sort { |a, b|
  (test(?s, a) <=> test(?s, b)).then { |res| res.zero? ? (test(?M, b) <=> test(?M, a)) : res }.
  then { |res| res.zero? ? (a <=> b) : res }
}

不过日常开发里，nonzero? ||的写法更常用也更简洁。

四、实现惰性求值的多条件排序 #

如果有高成本的排序条件（比如读取大文件统计内容），我们就需要惰性求值——只有当前面的条件无法区分两个元素时，才去计算后面的高成本条件。这时候就不能用sort_by提前预计算所有条件了，得用块形式的sort，在比较过程中按需计算：

比如我们要先按文件大小（低成本）升序，再按文件中某个目标字符串的出现次数（高成本）降序排序：

Dir["*"].sort do |a, b|
  # 先比较文件大小
  size_comp = test(?s, a) <=> test(?s, b)
  # 大小不相等，直接返回结果，不用管后面的高成本计算
  next size_comp unless size_comp.zero?

  # 只有大小相等时，才去读取文件统计字符串出现次数
  a_matches = File.read(a).scan(/target_string/).size
  b_matches = File.read(b).scan(/target_string/).size
  # 降序排列，所以用b的结果和a比较
  b_matches <=> a_matches
end

这样一来，只有当两个文件大小完全相等时，才会触发高成本的文件读取和统计操作，完美避免了不必要的资源消耗。

如果条件更多，我们可以把逻辑拆得更清晰：

Dir["*"].sort do |a, b|
  # 第一个条件：文件大小升序
  comp = test(?s, a) <=> test(?s, b)
  next comp unless comp.zero?

  # 第二个条件：修改时间降序
  comp = test(?M, b) <=> test(?M, a)
  next comp unless comp.zero?

  # 第三个条件：文件名升序
  a <=> b
end

每一步都用next提前返回非零的比较结果，只有当前面的条件完全相等时，才会进入下一个条件的计算，逻辑一目了然，而且完全是惰性的。

总结 #

• 低成本多条件排序：用sort_by，效率高代码简洁，适合所有条件计算成本都很低的场景；
• 组合<=>注意：别照搬Perl的or写法，Ruby里用nonzero? ||或者next逻辑才是正确姿势；
• 高成本条件排序：用块形式的sort，按需计算后续条件，实现惰性求值，避免资源浪费。

内容的提问来源于stack exchange，提问作者Adam Spiers