Ruby 检查是否所有子字符串都包含在另一个字符串数组中

我有两个字符串数组

order_items=["2832","3284","9832","9234"]
uri=["orderaccept/order_items/3284/cancel","orderaccept/order_items/9234/cancel"]

我想找到

order\u items

中不属于

uri

的所有元素。在这种情况下，它应该返回

2832

和

9832

请随意编辑两个数组的内容。我找不到类似的问题，但如果已经提出，请与我联系。

作为变体：

order_items.select { |item| uri.none? { |u| u.include?(item) } }

order_项目。选择{| i |！uri.join.include？i}

更新

order_items=["2832","3284","9832","9234"]
uri=["orderaccept/order_items/3284/cancel","orderaccept/order_items/9234/cancel"]

require 'benchmark'
joined = uri.join
n = 1_000_000
Benchmark.bm do |x|
  x.report("select:") { n.times do  order_items.select{|i| !uri.join.include? i}; end }
  x.report("reject:") { n.times do  order_items.reject{|i| uri.join.include? i}; end }
  x.report("reject2:") { n.times do  order_items.reject{|i| joined.include? i}; end }
  x.report("none?:") { n.times do  order_items.select { |item| uri.none? { |u| u.include?(item) } }; end }
  x.report("substr:") { n.times do  order_items - uri.map { |e| e.gsub /\D/, '' }; end }
  x.report("subt+substr:") {n.times do order_items - uri.map { |i| i[24..27] }; end }
end

它产生了

               user       system      total        real
select:       4.181000   0.015000   4.196000 (  4.275000)
reject:       3.931000   0.000000   3.931000 (  3.925000)
reject2:      1.388000   0.000000   1.388000 (  1.440000)
none?:        4.462000   0.000000   4.462000 (  4.490000)
substr:       26.582000  0.016000   26.598000( 26.675000)
subt+substr:  3.167000   0.000000   3.167000 (  3.170000)

作为一种变体：

order_项目。选择{| i |！uri.join.include？i}

更新

order_items=["2832","3284","9832","9234"]
uri=["orderaccept/order_items/3284/cancel","orderaccept/order_items/9234/cancel"]

require 'benchmark'
joined = uri.join
n = 1_000_000
Benchmark.bm do |x|
  x.report("select:") { n.times do  order_items.select{|i| !uri.join.include? i}; end }
  x.report("reject:") { n.times do  order_items.reject{|i| uri.join.include? i}; end }
  x.report("reject2:") { n.times do  order_items.reject{|i| joined.include? i}; end }
  x.report("none?:") { n.times do  order_items.select { |item| uri.none? { |u| u.include?(item) } }; end }
  x.report("substr:") { n.times do  order_items - uri.map { |e| e.gsub /\D/, '' }; end }
  x.report("subt+substr:") {n.times do order_items - uri.map { |i| i[24..27] }; end }
end

它产生了

               user       system      total        real
select:       4.181000   0.015000   4.196000 (  4.275000)
reject:       3.931000   0.000000   3.931000 (  3.925000)
reject2:      1.388000   0.000000   1.388000 (  1.440000)
none?:        4.462000   0.000000   4.462000 (  4.490000)
substr:       26.582000  0.016000   26.598000( 26.675000)
subt+substr:  3.167000   0.000000   3.167000 (  3.170000)

---

我猜数组减法在这里更适用，因为它对将来的代码修订是自描述性的（您确实愿意从数组中减去不必要的项，不是吗？）

UPDOoups…基准测试迫使我准确思考，例如：

order_items - uri.map { |i| i[24..27] }

基准：

order_items=["2832","3284","9832","9234"]
uri=["orderaccept/order_items/3284/cancel","orderaccept/order_items/9234/cancel"]

require 'benchmark'
n = 1_000_000
Benchmark.bm do |x|
  x.report("select:") { n.times do  order_items.select{|i| !uri.join.include? i}; end }
  x.report("reject:") { n.times do  order_items.reject{|i| uri.join.include? i}; end }
  x.report("none?:") { n.times do  order_items.select { |item| uri.none? { |u| u.include?(item) } }; end }
  x.report("subt+gsub:") { n.times do order_items - uri.map { |e| e.gsub /\D/, '' }; end }
  x.report("subt+substr:") {n.times do order_items - uri.map { |i| i[24..27] }; end }
end

屈服：

       user     system      total        real
select:  7.200000   0.000000   7.200000 (  7.206846)
reject:  6.240000   0.000000   6.240000 (  6.253924)
none?:  9.230000   0.020000   9.250000 (  9.282425)
subt+gsub: 43.440000   0.000000  43.440000 ( 43.491133)
subt+substr:  5.320000   0.010000   5.330000 (  5.333616)

---

我猜数组减法在这里更适用，因为它对将来的代码修订是自描述性的（您确实愿意从数组中减去不必要的项，不是吗？）

UPDOoups…基准测试迫使我准确思考，例如：

order_items - uri.map { |i| i[24..27] }

基准：

order_items=["2832","3284","9832","9234"]
uri=["orderaccept/order_items/3284/cancel","orderaccept/order_items/9234/cancel"]

require 'benchmark'
n = 1_000_000
Benchmark.bm do |x|
  x.report("select:") { n.times do  order_items.select{|i| !uri.join.include? i}; end }
  x.report("reject:") { n.times do  order_items.reject{|i| uri.join.include? i}; end }
  x.report("none?:") { n.times do  order_items.select { |item| uri.none? { |u| u.include?(item) } }; end }
  x.report("subt+gsub:") { n.times do order_items - uri.map { |e| e.gsub /\D/, '' }; end }
  x.report("subt+substr:") {n.times do order_items - uri.map { |i| i[24..27] }; end }
end

屈服：

       user     system      total        real
select:  7.200000   0.000000   7.200000 (  7.206846)
reject:  6.240000   0.000000   6.240000 (  6.253924)
none?:  9.230000   0.020000   9.250000 (  9.282425)
subt+gsub: 43.440000   0.000000  43.440000 ( 43.491133)
subt+substr:  5.320000   0.010000   5.330000 (  5.333616)

---

使用

join

是个好主意，但是使用

选择
和
一起使用并不优雅。您应该使用
拒绝
，而不使用
。此外，为了提高代码的效率，您必须在块外执行
join
。否则，对性能没有好处，直接表达意图，Jimmy的答案会更好。@YevgeniyAnfilofyev我也对subtract进行了基准测试，我看到了一个丑陋的生产力，并开始了一场黑客攻击，依靠
uri
包含
order\u items
中固定位置的所有字符串：
order\u items-uri.map{| i | i[24..27]}
。它在可接受的时间范围内运行，但仍然比reject2方法慢（尽管它绝对不灵活）@mudasobwa刚刚添加了您的上一种方法Jimmy的答案更适合我的简单需求…但我很欣赏另一种方法。只是展示了在Ruby中可以使用多少种方法。使用
join
是个好主意，但使用
select
with
！
并不优雅。您应该使用
拒绝
！
。此外，为了提高代码的效率，你必须在代码块之外加入
。
否则，没有性能优势，直接表达意图，Jimmy的答案会更好。@YevgeniyAnfilofyev我也在subtract上运行了基准测试，我看到了一个糟糕的生产效率，并依靠所有的s进行了破解
uri
中的字符串包含固定位置的
order\u items
：
order\u items-uri.map{i|i[24..27]}
。它在可接受的时间范围内运行，但仍然比reject2方法慢（尽管它绝对不灵活）@mudasobwa刚刚添加了你的上一种方法Jimmy的答案更适合我的简单需求…但是我很欣赏另一种方法。只是展示了Ruby可以用多少种方法来做一些事情。哇…太酷了。我本来应该写的东西至少有几行长。（当然，我只是这门语言的新手。）哇…太酷了。我本来应该写的东西至少有几行长。（当然，我只是这门语言的新手。）