Ruby 连字号的切换顺序

解析连字符单词列表并返回开头和结尾单词的最佳方法是什么

输入：

spider-man
wonder-woman

输出：

man-spider
woman-wonder

---

你可以拆分它，然后将其反转

"spider-man".split('-').reverse.join('-')
 #=> "man-spider"

您可以使用，并且

---

你可以用正则表达式

"spider-man".gsub(/^(.+)-(.+)$/, '\2-\1')
#=> "man-spider"

---

它的速度将是@rohit89解决方案的两倍；）

看起来是基准时间：

require 'fruity'

STR = 'spider-man'

compare do
  split_reverse_join {STR.split('-').reverse.join('-') }
  regex { STR.gsub(/^(.+)-(.+)$/, '\2-\1') }
end

# >> Running each test 2048 times. Test will take about 1 second.
# >> split_reverse_join is faster than regex by 3x ± 0.1

比较模式的细微变化：

require 'fruity'

STR = 'spider-man'

compare do
  regex1 { STR.gsub(/^(.+)-(.+)$/, '\2-\1') }
  regex2 { STR.gsub(/^([^-]*)-(.+)$/, '\2-\1') }
end
# >> Running each test 1024 times. Test will take about 1 second.
# >> regex1 is similar to regex2

将

gsub

与

sub

进行比较：

compare do
  gsub_regex { STR.gsub(/^(.+)-(.+)$/, '\2-\1') }
  sub_regex { STR.sub(/^(.+)-(.+)$/, '\2-\1') }
end
# >> Running each test 2048 times. Test will take about 1 second.
# >> sub_regex is faster than gsub_regex by 70.0% ± 10.0%

sub

总是比

gsub

快，因为它会在第一次搜索命中后跳出，而不是寻找其他命中

---

---

最快的将是最丑的<代码>位置=结构索引（“-”）；str[pos+1..-1]+“-”+str[0…pos]

---

所以你会用手指轻敲，等待它结束？这里有一些关于分裂，加工，连接的东西。我想它读起来更好，但我还是更喜欢直接处理字符串，就像你所做的那样。如果你想做基准测试，也许用

（[^-]*）

代替第一个

（.+）

更快（未经测试）。您也可以使用

sub

而不是

gsub

@CarySwoveland，我认为split解决方案更为惯用。就速度而言，你可以选择类似于

pos=str.index（“-”）的东西；str[pos+1..-1]+“-”+str[0…pos]

。而且，当您直接使用字符串时，您应该始终注意它的易变性。@Casimir et Hippolyte我不确定

（[^-]*）

是否可以在这里工作。Regex大约比使用这些方法慢3倍。欢迎使用堆栈溢出。不要向我们索要代码，你需要研究，然后尝试，然后，当你有问题时，展示你为解决问题而编写的最小代码，一些输入和输出数据，我们会帮助你。实际上，我们无法判断您是否尝试过，而且看起来您是在要求我们为您编写代码，这不是堆栈溢出的目的。最快的将是最丑的<代码>位置=结构索引（“-”）；str[pos+1..-1]+“-”+str[0…pos]我做了几次测试，结果非常不稳定，介于60%和3x之间（但总是支持拆分/连接方法）。我无法对此做出评论，因为我不知道您是如何做基准测试的。我现在几乎只使用Fruity，因为它的测试和报告非常一致。运行多个测试通常会返回上述结果。使用

sub

进行多个测试后，编写

（.*）-

似乎比

^（[^-]*）-

更快（或相等）。结论：也许使用

（*）literal

可以实现内部优化（如快速搜索算法），而更具描述性/手动的

^（[^-]*）literal

则禁止这种优化（其他可能的情况是，（很小的）差异只是由于模式编译时间）。惊人的分析，非常感谢您的支持

compare do
  gsub_regex { STR.gsub(/^(.+)-(.+)$/, '\2-\1') }
  sub_regex { STR.sub(/^(.+)-(.+)$/, '\2-\1') }
end
# >> Running each test 2048 times. Test will take about 1 second.
# >> sub_regex is faster than gsub_regex by 70.0% ± 10.0%

compare do
  split_reverse_join {STR.split('-').reverse.join('-') }
  regex { STR.gsub(/^(.+)-(.+)$/, '\2-\1') }
  pos {
    pos = STR.index("-")
    STR[pos+1..-1] + "-" + STR[0...pos]   
  }
end

# >> Running each test 2048 times. Test will take about 1 second.
# >> pos is faster than split_reverse_join by 19.999999999999996% ± 10.0%
# >> split_reverse_join is faster than regex by 3x ± 0.1