例:
[12,23,987,43
删除“ [
”的最快,最有效的方法是什么,也许chop()
在第一个字符之外使用a ?
例:
[12,23,987,43
删除“ [
”的最快,最有效的方法是什么,也许chop()
在第一个字符之外使用a ?
delete_prefix
\ delete_prefix!
)进行了基准测试,它们非常快。不太喜欢以前的速度,但是可读性意味着它们是很不错的新选择!
Answers:
我喜欢使用类似的东西:
asdf =“ [12,23,987,43” asdf [0] =” as #>>“ 12,23,987,43”
我一直在寻找最快,最易读的处理方式:
require 'benchmark'
N = 1_000_000
puts RUBY_VERSION
STR = "[12,23,987,43"
Benchmark.bm(7) do |b|
b.report('[0]') { N.times { "[12,23,987,43"[0] = '' } }
b.report('sub') { N.times { "[12,23,987,43".sub(/^\[+/, "") } }
b.report('gsub') { N.times { "[12,23,987,43".gsub(/^\[/, "") } }
b.report('[1..-1]') { N.times { "[12,23,987,43"[1..-1] } }
b.report('slice') { N.times { "[12,23,987,43".slice!(0) } }
b.report('length') { N.times { "[12,23,987,43"[1..STR.length] } }
end
在我的Mac Pro上运行:
1.9.3
user system total real
[0] 0.840000 0.000000 0.840000 ( 0.847496)
sub 1.960000 0.010000 1.970000 ( 1.962767)
gsub 4.350000 0.020000 4.370000 ( 4.372801)
[1..-1] 0.710000 0.000000 0.710000 ( 0.713366)
slice 1.020000 0.000000 1.020000 ( 1.020336)
length 1.160000 0.000000 1.160000 ( 1.157882)
更新以合并另一个建议的答案:
require 'benchmark'
N = 1_000_000
class String
def eat!(how_many = 1)
self.replace self[how_many..-1]
end
def first(how_many = 1)
self[0...how_many]
end
def shift(how_many = 1)
shifted = first(how_many)
self.replace self[how_many..-1]
shifted
end
alias_method :shift!, :shift
end
class Array
def eat!(how_many = 1)
self.replace self[how_many..-1]
end
end
puts RUBY_VERSION
STR = "[12,23,987,43"
Benchmark.bm(7) do |b|
b.report('[0]') { N.times { "[12,23,987,43"[0] = '' } }
b.report('sub') { N.times { "[12,23,987,43".sub(/^\[+/, "") } }
b.report('gsub') { N.times { "[12,23,987,43".gsub(/^\[/, "") } }
b.report('[1..-1]') { N.times { "[12,23,987,43"[1..-1] } }
b.report('slice') { N.times { "[12,23,987,43".slice!(0) } }
b.report('length') { N.times { "[12,23,987,43"[1..STR.length] } }
b.report('eat!') { N.times { "[12,23,987,43".eat! } }
b.report('reverse') { N.times { "[12,23,987,43".reverse.chop.reverse } }
end
结果是:
2.1.2
user system total real
[0] 0.300000 0.000000 0.300000 ( 0.295054)
sub 0.630000 0.000000 0.630000 ( 0.631870)
gsub 2.090000 0.000000 2.090000 ( 2.094368)
[1..-1] 0.230000 0.010000 0.240000 ( 0.232846)
slice 0.320000 0.000000 0.320000 ( 0.320714)
length 0.340000 0.000000 0.340000 ( 0.341918)
eat! 0.460000 0.000000 0.460000 ( 0.452724)
reverse 0.400000 0.000000 0.400000 ( 0.399465)
另一个/^./
用于查找第一个字符的方法:
require 'benchmark'
N = 1_000_000
class String
def eat!(how_many = 1)
self.replace self[how_many..-1]
end
def first(how_many = 1)
self[0...how_many]
end
def shift(how_many = 1)
shifted = first(how_many)
self.replace self[how_many..-1]
shifted
end
alias_method :shift!, :shift
end
class Array
def eat!(how_many = 1)
self.replace self[how_many..-1]
end
end
puts RUBY_VERSION
STR = "[12,23,987,43"
Benchmark.bm(7) do |b|
b.report('[0]') { N.times { "[12,23,987,43"[0] = '' } }
b.report('[/^./]') { N.times { "[12,23,987,43"[/^./] = '' } }
b.report('[/^\[/]') { N.times { "[12,23,987,43"[/^\[/] = '' } }
b.report('sub+') { N.times { "[12,23,987,43".sub(/^\[+/, "") } }
b.report('sub') { N.times { "[12,23,987,43".sub(/^\[/, "") } }
b.report('gsub') { N.times { "[12,23,987,43".gsub(/^\[/, "") } }
b.report('[1..-1]') { N.times { "[12,23,987,43"[1..-1] } }
b.report('slice') { N.times { "[12,23,987,43".slice!(0) } }
b.report('length') { N.times { "[12,23,987,43"[1..STR.length] } }
b.report('eat!') { N.times { "[12,23,987,43".eat! } }
b.report('reverse') { N.times { "[12,23,987,43".reverse.chop.reverse } }
end
结果是:
# >> 2.1.5
# >> user system total real
# >> [0] 0.270000 0.000000 0.270000 ( 0.270165)
# >> [/^./] 0.430000 0.000000 0.430000 ( 0.432417)
# >> [/^\[/] 0.460000 0.000000 0.460000 ( 0.458221)
# >> sub+ 0.590000 0.000000 0.590000 ( 0.590284)
# >> sub 0.590000 0.000000 0.590000 ( 0.596366)
# >> gsub 1.880000 0.010000 1.890000 ( 1.885892)
# >> [1..-1] 0.230000 0.000000 0.230000 ( 0.223045)
# >> slice 0.300000 0.000000 0.300000 ( 0.299175)
# >> length 0.320000 0.000000 0.320000 ( 0.325841)
# >> eat! 0.410000 0.000000 0.410000 ( 0.409306)
# >> reverse 0.390000 0.000000 0.390000 ( 0.393044)
这是关于更快的硬件和较新版本的Ruby的另一个更新:
2.3.1
user system total real
[0] 0.200000 0.000000 0.200000 ( 0.204307)
[/^./] 0.390000 0.000000 0.390000 ( 0.387527)
[/^\[/] 0.360000 0.000000 0.360000 ( 0.360400)
sub+ 0.490000 0.000000 0.490000 ( 0.492083)
sub 0.480000 0.000000 0.480000 ( 0.487862)
gsub 1.990000 0.000000 1.990000 ( 1.988716)
[1..-1] 0.180000 0.000000 0.180000 ( 0.181673)
slice 0.260000 0.000000 0.260000 ( 0.266371)
length 0.270000 0.000000 0.270000 ( 0.267651)
eat! 0.400000 0.010000 0.410000 ( 0.398093)
reverse 0.340000 0.000000 0.340000 ( 0.344077)
为什么gsub这么慢?
搜索/替换后,gsub
必须先检查可能的其他匹配项,然后才能判断是否完成。sub
只能完成一个。考虑gsub
至少要打两次sub
电话。
此外,请务必记住gsub
,并且,sub
由于正则表达式写得不好,匹配比子字符串搜索要慢得多,因此也很重要。如果可能的话,锚定正则表达式以从中获得最大的速度。这里有关于Stack Overflow的答案,证明了这一点,因此如果您需要更多信息,请进行搜索。
"[12,23,987,43".delete "["
what about "[12,23,987,43".shift ?
“?"[12,23,987,43".shift NoMethodError: undefined method
“ [12,23,987,43”:字符串”的“移位”怎么样?
与上述Pablo的答案类似,但是阴影清洁剂:
str[1..-1]
将数组从1返回到最后一个字符。
'Hello World'[1..-1]
=> "ello World"
str[1,]
与上述相比,性能如何?
str[1,]
返回第二个字符,因为范围是1:nil
。您需要提供实际计算出的长度,或者提供一定要保证比长度str[1,999999]
更长的长度,例如(当然要使用int_max)以获取整条尾巴。[1..-1]
更干净,可能更快,因为您不需要手动操作长度(请参见基准测试中的[1..length])
str[1..-2]
我们可以使用slice来做到这一点:
val = "abc"
=> "abc"
val.slice!(0)
=> "a"
val
=> "bc"
使用slice!
我们可以通过指定字符索引来删除任何字符。
slice!(0)
确实应该选择这种优美的答案,因为asdf[0] = ''
用来删除第一个字符是荒谬的(就像将gsub与regex一起使用并用榴弹炮射击苍蝇一样)。
[]=
似乎很不直观,但并不需要那么多的基础C代码,而在这里slice!
需要进行额外的工作。加起来。参数可能是“哪个更具可读性?” 我发现使用的是[]=
可读的,但是我来自C-> Perl背景,这可能使我的想法发色。Java开发人员可能会认为它的可读性较差。只要可以轻松理解和维护并且不会过度加载CPU,任何一种方法都可以完成任务。
从Ruby 2.5开始,您可以以可读的方式使用delete_prefix
或delete_prefix!
实现此目的。
在这种情况下"[12,23,987,43".delete_prefix("[")
。
更多信息在这里:
'invisible'.delete_prefix('in') #=> "visible"
'pink'.delete_prefix('in') #=> "pink"
NB也可以用它来从一个字符串的结尾删除项目delete_suffix
和delete_suffix!
'worked'.delete_suffix('ed') #=> "work"
'medical'.delete_suffix('ed') #=> "medical"
编辑:
使用Tin Man的基准测试设置,它看起来也非常快(在最后两个条目delete_p
和下方delete_p!
)。尽管可读性很强,但并没有充分利用以前对速度的热爱。
2.5.0
user system total real
[0] 0.174766 0.000489 0.175255 ( 0.180207)
[/^./] 0.318038 0.000510 0.318548 ( 0.323679)
[/^\[/] 0.372645 0.001134 0.373779 ( 0.379029)
sub+ 0.460295 0.001510 0.461805 ( 0.467279)
sub 0.498351 0.001534 0.499885 ( 0.505729)
gsub 1.669837 0.005141 1.674978 ( 1.682853)
[1..-1] 0.199840 0.000976 0.200816 ( 0.205889)
slice 0.279661 0.000859 0.280520 ( 0.285661)
length 0.268362 0.000310 0.268672 ( 0.273829)
eat! 0.341715 0.000524 0.342239 ( 0.347097)
reverse 0.335301 0.000588 0.335889 ( 0.340965)
delete_p 0.222297 0.000832 0.223129 ( 0.228455)
delete_p! 0.225798 0.000747 0.226545 ( 0.231745)
我更喜欢这样:
str = "[12,23,987,43"
puts str[1..-1]
>> 12,23,987,43
例如:a =“一二三”
1.9.2-p290 > a = "One Two Three"
=> "One Two Three"
1.9.2-p290 > a = a[1..-1]
=> "ne Two Three"
1.9.2-p290 > a = a[1..-1]
=> "e Two Three"
1.9.2-p290 > a = a[1..-1]
=> " Two Three"
1.9.2-p290 > a = a[1..-1]
=> "Two Three"
1.9.2-p290 > a = a[1..-1]
=> "wo Three"
这样,您可以删除字符串的第一个字符。
简单的方法:
str = "[12,23,987,43"
removed = str[1..str.length]
很棒的方式:
class String
def reverse_chop()
self[1..self.length]
end
end
"[12,23,987,43".reverse_chop()
(注意:更喜欢简单的方法:))
"[12,23,987,43".reverse.chop.reverse
感谢@ the-tin-man整理了基准!
,我真的不喜欢这些解决方案。他们要么需要采取额外的步骤来获得结果([0] = ''
,.strip!
),要么它们对所发生的事情不是很语义/不清楚([1..-1]
:“ Um,范围是1到负1?写出来(.gsub
,.length
)。
我们正在尝试的是“移位”(以Array的说法),但是返回剩余的字符,而不是被移位的字符。让我们使用我们的Ruby通过字符串使之成为可能!我们可以使用快速括弧操作,但是要给它起个好名字,并用一个arg来指定要砍掉前面的内容:
class String
def eat!(how_many = 1)
self.replace self[how_many..-1]
end
end
但是,对于这种快速但笨拙的括号操作,我们可以做更多的事情。在此过程中,为完整起见,让我们为String编写一个#shift
和#first
字符串(为什么Array会很有趣?),并使用一个arg来指定我们要从头开始删除的字符数:
class String
def first(how_many = 1)
self[0...how_many]
end
def shift(how_many = 1)
shifted = first(how_many)
self.replace self[how_many..-1]
shifted
end
alias_method :shift!, :shift
end
好的,现在,我们有了一种清晰明确的方法,可以使用与Array#first
and一致的方法从字符串的开头提取字符Array#shift
(实际上应该是bang方法?)。而且,我们也可以轻松获得修改后的字符串#eat!
。嗯,我们应该eat!
和Array分享我们的新功能吗?为什么不!
class Array
def eat!(how_many = 1)
self.replace self[how_many..-1]
end
end
现在我们可以:
> str = "[12,23,987,43" #=> "[12,23,987,43"
> str.eat! #=> "12,23,987,43"
> str #=> "12,23,987,43"
> str.eat!(3) #=> "23,987,43"
> str #=> "23,987,43"
> str.first(2) #=> "23"
> str #=> "23,987,43"
> str.shift!(3) #=> "23,"
> str #=> "987,43"
> arr = [1,2,3,4,5] #=> [1, 2, 3, 4, 5]
> arr.eat! #=> [2, 3, 4, 5]
> arr #=> [2, 3, 4, 5]
那更好!
chip()
代替chop()
(和chimp()
的类似物chomp()
)。
class String
def bye_felicia()
felicia = self.strip[0] #first char, not first space.
self.sub(felicia, '')
end
end