blocks|key|1584687|text|与您的示例一样简单的比较，没有太大的区别，但由于比较公式变得复杂，最好避免将<=>与块一起使用，因为您传递的块将针对数组的每个元素进行计算，从而导致冗余。请考虑以下内容：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1584688|array.sort{%7Cx,+y%7C+some_expensive_method(x)+<=>+some_expensive_method(y)}|code-block|syntax|javascript|1584689|在这种情况下，将针对array每个可能的元素对评估some_expensive_method。|1584690|在您的特定情况下，可以使用reverse来避免在<=>中使用块。|1584691|array.sort_by{%7Cx%7C+some_expensive_method(x)}.reverse|1584692|这就是Schwartzian变换。|1584693|entityMap^0|12|3|0|0|A|5|P|L|0|D|7|O|3|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|O|3|P|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|19|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|T|$]]

With comparison as simple as your example, there is not much difference, but as the formula for comparison gets complicated, it is better to avoid using <code>&lt;=&gt;</code> with a block because the block you pass will be evaluated for each element of the array, causing redundancy. Consider this:

<pre><code>array.sort{|x, y| some_expensive_method(x) &lt;=&gt; some_expensive_method(y)}
</code></pre>

In this case, <code>some_expensive_method</code> will be evaluated for each possible pair of element of <code>array</code>.

In your particular case, use of a block with <code>&lt;=&gt;</code> can be avoided with <code>reverse</code>.

<pre><code>array.sort_by{|x| some_expensive_method(x)}.reverse
</code></pre>

This is called Schwartzian transform.

blocks|key|1584929|text|这两行执行相同的操作(创建一个新数组，该数组是反向排序的)。主要的争论是关于可读性和性能。array.sort.reverse!比array.sort{%7Cx,y%7C+y<=>x}更具可读性--我想我们可以同意这一点。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1584930|对于性能部分，我创建了一个快速基准测试脚本，它在我的系统上提供了以下内容(ruby+1.9.3p392+[x86_64-linux])：|1584931|++++++++++++++++++++++++++++++user+++++system++++++total++++++++real
array.sort.reverse++++++++1.330000+++0.000000+++1.330000+(++1.334667)
array.sort.reverse!+++++++1.200000+++0.000000+++1.200000+(++1.198232)
array.sort!.reverse!++++++1.200000+++0.000000+++1.200000+(++1.199296)
array.sort{%7Cx,y%7C+y<=>x}+++5.220000+++0.000000+++5.220000+(++5.239487)|code-block|syntax|javascript|1584932|对于基准测试脚本的多次执行，运行时间非常恒定。|1584933|array.sort.reverse+(有没有!)比array.sort{%7Cx,y%7C+y<=>x}快得多。因此，我建议这样做。|1584934|1584935|下面是作为参考的脚本：|1584936|#!/usr/bin/env+ruby
require+'benchmark'

Benchmark.bm+do%7Cb%7C
++master+=+(1..1_000_000).map(&:to_s).shuffle
++a+=+master.dup
++b.report("array.sort.reverse++++++")+do
++++a.sort.reverse
++end

++a+=+master.dup
++b.report("array.sort.reverse!+++++")+do
++++a.sort.reverse!
++end

++a+=+master.dup
++b.report("array.sort!.reverse!++++")+do
++++a.sort!.reverse!
++end

++a+=+master.dup
++b.report("array.sort{%7Cx,y%7C+y<=>x}+")+do
++++a.sort{%7Cx,y%7C+y<=>x}
++end
end|1584937|entityMap^0|19|J|1T|N|0|11|T|0|0|0|0|I|N|1|Q|N|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|15|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|16|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|1F|8|@]|D|@]|E|$]]|$1|T|3|U|5|J|7|1G|8|@]|D|@]|E|$K|L]]|$1|V|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|W|$]]

Both lines do the same (create a new array, which is reverse sorted). The main argument is about readability and performance. <code>array.sort.reverse!</code> is more readable than <code>array.sort{|x,y| y&lt;=&gt;x}</code> - I think we can agree here.

For the performance part, I created a quick benchmark script, which gives the following on my system (<code>ruby 1.9.3p392 [x86_64-linux]</code>):

<pre><code> user system total real
array.sort.reverse 1.330000 0.000000 1.330000 ( 1.334667)
array.sort.reverse! 1.200000 0.000000 1.200000 ( 1.198232)
array.sort!.reverse! 1.200000 0.000000 1.200000 ( 1.199296)
array.sort{|x,y| y&lt;=&gt;x} 5.220000 0.000000 5.220000 ( 5.239487)
</code></pre>

Run times are pretty constant for multiple executions of the benchmark script.

<code>array.sort.reverse</code> (with or without <code>!</code>) is way faster than <code>array.sort{|x,y| y&lt;=&gt;x}</code>. Thus, I recommend that.

<hr>

Here is the script as a Reference:

<pre><code>#!/usr/bin/env ruby
require 'benchmark'

Benchmark.bm do|b|
 master = (1..1_000_000).map(&amp;:to_s).shuffle
 a = master.dup
 b.report("array.sort.reverse ") do
 a.sort.reverse
 end

 a = master.dup
 b.report("array.sort.reverse! ") do
 a.sort.reverse!
 end

 a = master.dup
 b.report("array.sort!.reverse! ") do
 a.sort!.reverse!
 end

 a = master.dup
 b.report("array.sort{|x,y| y&lt;=&gt;x} ") do
 a.sort{|x,y| y&lt;=&gt;x}
 end
end
</code></pre>

blocks|key|1584948|text|倒车！速度更快|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1584949|基准测试通常是无法替代的。虽然它在较短的脚本中可能没有区别，但#reverse！方法比使用“太空船”操作符进行排序要快得多。例如，在MRI+Ruby+2.0上，并给出了以下基准代码：|1584950|require+'benchmark'

array+=+["one",+"two",+"three"]
loops+=+1_000_000

Benchmark.bmbm+do+%7Cbm%7C
++++bm.report('reverse!')++{+loops.times+{array.sort.reverse!}+}
++++bm.report('spaceship')+{+loops.times+{array.sort+{%7Cx,y%7C+y<=>x}+}}
end|code-block|syntax|javascript|1584951|系统会报告#reverse！几乎是使用组合比较运算符的两倍。|1584952|++++++++++++++++user+++++system++++++total++++++++real
reverse!++++0.340000+++0.000000+++0.340000+(++0.344198)
spaceship+++0.590000+++0.010000+++0.600000+(++0.595747)|1584953|我的建议是:在给定的上下文中使用语义上更有意义的代码，除非您正在紧凑的循环中运行。|1584954|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

<h2>Reverse! is Faster</h2>

There's often no substitute for benchmarking. While it probably makes no difference in shorter scripts, the #reverse! method is significantly faster than sorting using the "spaceship" operator. For example, on MRI Ruby 2.0, and given the following benchmark code:

<pre><code>require 'benchmark'

array = ["one", "two", "three"]
loops = 1_000_000

Benchmark.bmbm do |bm|
 bm.report('reverse!') { loops.times {array.sort.reverse!} }
 bm.report('spaceship') { loops.times {array.sort {|x,y| y&lt;=&gt;x} }}
end
</code></pre>

the system reports that #reverse! is almost twice as fast as using the combined comparison operator.

<pre><code> user system total real
reverse! 0.340000 0.000000 0.340000 ( 0.344198)
spaceship 0.590000 0.010000 0.600000 ( 0.595747)
</code></pre>

My advice: use whichever is more semantically meaningful in a given context, unless you're running in a tight loop.

blocks|key|1585090|text|在我的机器上使用tessi的基准测试时，我得到了一些有趣的结果。我在OS+X系统上运行ruby+2.0.0p195+[x86_64-darwin12.3.0]，也就是最新版本的Ruby2。我在Benchmark模块中使用了bmbm而不是bm。我的时间安排是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1585091|Rehearsal+-------------------------------------------------------------
array.sort.reverse:+++++++++1.010000+++0.000000+++1.010000+(++1.020397)
array.sort.reverse!:++++++++0.810000+++0.000000+++0.810000+(++0.808368)
array.sort!.reverse!:+++++++0.800000+++0.010000+++0.810000+(++0.809666)
array.sort{%7Cx,y%7C+y<=>x}:++++0.300000+++0.000000+++0.300000+(++0.291002)
array.sort!{%7Cx,y%7C+y<=>x}:+++0.100000+++0.000000+++0.100000+(++0.105345)
----------------------------------------------------+total:+3.030000sec

++++++++++++++++++++++++++++++++user+++++system++++++total++++++++real
array.sort.reverse:+++++++++0.210000+++0.000000+++0.210000+(++0.208378)
array.sort.reverse!:++++++++0.030000+++0.000000+++0.030000+(++0.027746)
array.sort!.reverse!:+++++++0.020000+++0.000000+++0.020000+(++0.020082)
array.sort{%7Cx,y%7C+y<=>x}:++++0.110000+++0.000000+++0.110000+(++0.107065)
array.sort!{%7Cx,y%7C+y<=>x}:+++0.110000+++0.000000+++0.110000+(++0.105359)|code-block|syntax|javascript|1585092|首先，请注意，在排练阶段，使用比较块的sort!是明显的赢家。Matz一定是在Ruby2中把它调出来了！|1585093|我发现的另一件非常奇怪的事情是array.sort.reverse!和array.sort!.reverse!在生产过程中表现出了多大的改进。它是如此极端，以至于我想知道我是不是搞砸了并传递了这些已经排序的数据，所以我在执行每个基准测试之前为排序或反向排序的数据添加了显式检查。|1585094|1585095|我的tessi脚本的变体如下：|1585096|#!/usr/bin/env+ruby
require+'benchmark'

class+Array
++def+sorted?
++++(1...length).each+{%7Ci%7C+return+false+if+self[i]+<+self[i-1]+}
++++true
++end

++def+reversed?
++++(1...length).each+{%7Ci%7C+return+false+if+self[i]+>+self[i-1]+}
++++true
++end
end

master+=+(1..1_000_000).map(&:to_s).shuffle

Benchmark.bmbm(25)+do%7Cb%7C
++a+=+master.dup
++puts+"uh-oh!"+if+a.sorted?
++puts+"oh-uh!"+if+a.reversed?
++b.report("array.sort.reverse:")+{+a.sort.reverse+}

++a+=+master.dup
++puts+"uh-oh!"+if+a.sorted?
++puts+"oh-uh!"+if+a.reversed?
++b.report("array.sort.reverse!:")+{+a.sort.reverse!+}

++a+=+master.dup
++puts+"uh-oh!"+if+a.sorted?
++puts+"oh-uh!"+if+a.reversed?
++b.report("array.sort!.reverse!:")+{+a.sort!.reverse!+}

++a+=+master.dup
++puts+"uh-oh!"+if+a.sorted?
++puts+"oh-uh!"+if+a.reversed?
++b.report("array.sort{%7Cx,y%7C+y<=>x}:")+{+a.sort{%7Cx,y%7C+y<=>x}+}

++a+=+master.dup
++puts+"uh-oh!"+if+a.sorted?
++puts+"oh-uh!"+if+a.reversed?
++b.report("array.sort!{%7Cx,y%7C+y<=>x}:")+{+a.sort!{%7Cx,y%7C+y<=>x}+}
end|1585097|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ruby-doc.org/stdlib-1.9.3/libdoc/benchmark/rdoc/Benchmark.html#method-c-bmbm^0|17|10|3A|2|33|4|0|0|0|J|5|0|F|J|Z|K|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@$9|16|A|17|1|18]]|E|$]]|$1|F|3|G|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1D|8|@$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1J|8|@]|D|@]|E|$]]|$1|R|3|S|5|H|7|1K|8|@]|D|@]|E|$I|J]]|$1|T|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]]|U|$V|$5|W|X|Y|E|$Z|10]]]]

In playing with tessi's benchmarks on my machine, I've gotten some interesting results. I'm running <code>ruby 2.0.0p195 [x86_64-darwin12.3.0]</code>, i.e., latest release of Ruby 2 on an OS X system. I used <a href="http://www.ruby-doc.org/stdlib-1.9.3/libdoc/benchmark/rdoc/Benchmark.html#method-c-bmbm" rel="nofollow">bmbm</a> rather than <code>bm</code> from the Benchmark module. My timings are:

<pre><code>Rehearsal -------------------------------------------------------------
array.sort.reverse: 1.010000 0.000000 1.010000 ( 1.020397)
array.sort.reverse!: 0.810000 0.000000 0.810000 ( 0.808368)
array.sort!.reverse!: 0.800000 0.010000 0.810000 ( 0.809666)
array.sort{|x,y| y&lt;=&gt;x}: 0.300000 0.000000 0.300000 ( 0.291002)
array.sort!{|x,y| y&lt;=&gt;x}: 0.100000 0.000000 0.100000 ( 0.105345)
---------------------------------------------------- total: 3.030000sec

 user system total real
array.sort.reverse: 0.210000 0.000000 0.210000 ( 0.208378)
array.sort.reverse!: 0.030000 0.000000 0.030000 ( 0.027746)
array.sort!.reverse!: 0.020000 0.000000 0.020000 ( 0.020082)
array.sort{|x,y| y&lt;=&gt;x}: 0.110000 0.000000 0.110000 ( 0.107065)
array.sort!{|x,y| y&lt;=&gt;x}: 0.110000 0.000000 0.110000 ( 0.105359)
</code></pre>

First, note that in the Rehearsal phase that <code>sort!</code> using a comparison block comes in as the clear winner. Matz must have tuned the heck out of it in Ruby 2!

The other thing that I found exceedingly weird was how much improvement <code>array.sort.reverse!</code> and <code>array.sort!.reverse!</code> exhibited in the production pass. It was so extreme it made me wonder whether I had somehow screwed up and passed these already sorted data, so I added explicit checks for sorted or reverse-sorted data prior to performing each benchmark.

<hr>

My variant of tessi's script follows:

<pre><code>#!/usr/bin/env ruby
require 'benchmark'

class Array
 def sorted?
 (1...length).each {|i| return false if self[i] &lt; self[i-1] }
 true
 end

 def reversed?
 (1...length).each {|i| return false if self[i] &gt; self[i-1] }
 true
 end
end

master = (1..1_000_000).map(&amp;:to_s).shuffle

Benchmark.bmbm(25) do|b|
 a = master.dup
 puts "uh-oh!" if a.sorted?
 puts "oh-uh!" if a.reversed?
 b.report("array.sort.reverse:") { a.sort.reverse }

 a = master.dup
 puts "uh-oh!" if a.sorted?
 puts "oh-uh!" if a.reversed?
 b.report("array.sort.reverse!:") { a.sort.reverse! }

 a = master.dup
 puts "uh-oh!" if a.sorted?
 puts "oh-uh!" if a.reversed?
 b.report("array.sort!.reverse!:") { a.sort!.reverse! }

 a = master.dup
 puts "uh-oh!" if a.sorted?
 puts "oh-uh!" if a.reversed?
 b.report("array.sort{|x,y| y&lt;=&gt;x}:") { a.sort{|x,y| y&lt;=&gt;x} }

 a = master.dup
 puts "uh-oh!" if a.sorted?
 puts "oh-uh!" if a.reversed?
 b.report("array.sort!{|x,y| y&lt;=&gt;x}:") { a.sort!{|x,y| y&lt;=&gt;x} }
end
</code></pre>

I have learned two array sorting methods in Ruby:

<pre><code>array = ["one", "two", "three"]
array.sort.reverse!
</code></pre>

or:

<pre><code>array = ["one", "two", "three"]
array.sort { |x,y| y&lt;=&gt;x }
</code></pre>

And I am not able to differentiate between the two. Which method is better and how exactly are they different in execution?

Sorting an array of strings in Ruby

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我在Ruby中学习了两种数组排序方法：array = ["one", "two", "three"]array.sort.reverse!或者：array = ["one", "two", "three"]array.sort { |x,y| y<=>x }我不能区分这两者。哪种方法更好，它们在执行过程中到底有什么不同...

问在Ruby中对字符串数组进行排序
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Ruby中对字符串数组进行排序EN