从字符串中删除第一个字符的最简单方法是什么?


176

例:

[12,23,987,43

删除“ [”的最快,最有效的方法是什么,也许chop()在第一个字符之外使用a ?


1
我已经编辑了答案,因此可以更改您选择的答案。看看您是否可以将它授予Jason Stirk的答案,因为他是最快的,而且可读性强。
Tin Man

3
根据以下答案,使用str [1 ..- 1]最快。
Achyut Rastogi

1
从Ruby 2.5开始,您可以使用delete_prefixdelete_prefix!-以下更多详细信息。我还没有时间进行基准测试,但是很快就会执行!
SRack

更新:我已经对新方法(delete_prefix\ delete_prefix!)进行了基准测试,它们非常快。不太喜欢以前的速度,但是可读性意味着它们是很不错的新选择!
SRack

Answers:


236

我喜欢使用类似的东西:

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的答案,证明了这一点,因此如果您需要更多信息,请进行搜索。


34
重要的是要注意,这仅在Ruby 1.9中有效。在Ruby 1.8中,这将从字符串中删除第一个字节而不是第一个字符,这不是OP想要的。
约尔格W¯¯米塔格

+1:我总是忘记,在字符串位置,您不仅可以分配单个字符,还可以插入子字符串。谢谢!
quetzalcoatl

"[12,23,987,43".delete "["
rupweb

4
这样会将其从所有位置删除,这不是OP想要的:“ ...第一个字符?”。
Tin Man

2
what about "[12,23,987,43".shift ?“?"[12,23,987,43".shift NoMethodError: undefined method “ [12,23,987,43”:字符串”的“移位”怎么样?
Tin Man

295

与上述Pablo的答案类似,但是阴影清洁剂:

str[1..-1]

将数组从1返回到最后一个字符。

'Hello World'[1..-1]
 => "ello World"

13
+1看一下我添加到答案中的基准测试结果。您的运行时最快,而且我认为它非常干净。
Tin Man

str[1,]与上述相比,性能如何?
Bohr

1
@Bohr:str[1,]返回第二个字符,因为范围是1:nil。您需要提供实际计算出的长度,或者提供一定要保证比长度str[1,999999]更长的长度,例如(当然要使用int_max)以获取整条尾巴。[1..-1]更干净,可能更快,因为您不需要手动操作长度(请参见基准测试中的[1..length])
quetzalcoatl

5
非常好的解决方案。顺便说一句,如果有人想删除第一个和最后一个字符:str[1..-2]
pisaruk 2014年

52

我们可以使用slice来做到这一点:

val = "abc"
 => "abc" 
val.slice!(0)
 => "a" 
val
 => "bc" 

使用slice!我们可以通过指定字符索引来删除任何字符。


2
slice!(0)确实应该选择这种优美的答案,因为asdf[0] = '' 用来删除第一个字符是荒谬的(就像将gsub与regex一起使用并用榴弹炮射击苍蝇一样)。
f055

1
尽管从表面上看[]=似乎很不直观,但并不需要那么多的基础C代码,而在这里slice!需要进行额外的工作。加起来。参数可能是“哪个更具可读性?” 我发现使用的是[]=可读的,但是我来自C-> Perl背景,这可能使我的想法发色。Java开发人员可能会认为它的可读性较差。只要可以轻松理解和维护并且不会过度加载CPU,任何一种方法都可以完成任务。
Tin Man

好。您知道一个函数在ROR中占用大量CPU负载时如何衡量吗?还是应该使用毫秒或纳秒为单位的执行时间差?
balanv '16

20

红宝石2.5+

从Ruby 2.5开始,您可以以可读的方式使用delete_prefixdelete_prefix!实现此目的。

在这种情况下"[12,23,987,43".delete_prefix("[")

更多信息在这里:

'invisible'.delete_prefix('in') #=> "visible"
'pink'.delete_prefix('in') #=> "pink"

NB也可以用它来从一个字符串的结尾删除项目delete_suffixdelete_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)


14

如果您始终要去除前括号,请执行以下操作:

"[12,23,987,43".gsub(/^\[/, "")

如果您只想删除第一个字符,并且知道它不会包含在多字节字符集中:

"[12,23,987,43"[1..-1]

要么

"[12,23,987,43".slice(1..-1)

1
我会用"[12,23,987,43".sub(/^\[+/, "")代替gsub(/^\[/, "")。第一个让正则表达式引擎找到所有匹配项,然后一次动作将其替换,并使用Ruby 1.9.3将速度提高大约2倍。
Tin Man

1
既然我们正在处理字符串,这应该是gsub(/\A\[/, "") 吗?
iceツ

6

低效的替代方案:

str.reverse.chop.reverse

4

例如: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" 

这样,您可以删除字符串的第一个字符。


3
这与杰森·斯特里克Jason Stirk)的答案相同,只有他几个月前才提交。
Tin Man

3

简单的方法:

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()

(注意:更喜欢简单的方法:))


1
如果您想保留“剁碎”的语义,您可以"[12,23,987,43".reverse.chop.reverse
Chris Heald

仅剥离一个字符是相当大的性能开销
Pablo Fernandez 2010年

7
为什么不使用[1 ..- 1]而不是[1..self.length]?
horseyguy 2010年

猴子打补丁的例子对于这个问题是不可行的,它只是无关紧要的和丑陋的IMO。
dredozubov 2014年

3

感谢@ 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#firstand一致的方法从字符串的开头提取字符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] 

那更好!


2
我记得几年前在Perl论坛上关于这样的函数的讨论,该函数的名称为chip()代替chop()(和chimp()的类似物chomp())。
马克·托马斯

2
str = "[12,23,987,43"

str[0] = ""

7
重要的是要注意,这仅在Ruby 1.9中有效。在Ruby 1.8中,这将从字符串中删除第一个字节而不是第一个字符,这不是OP想要的。
约尔格W¯¯米塔格

1

list = [1,2,3,4] list.drop(1)

# => [2,3,4]

List从数组的开头删除一个或多个元素,不对数组进行突变,而是返回数组本身而不是被删除的元素。



0

使用正则表达式:

str = 'string'
n = 1  #to remove first n characters

str[/.{#{str.size-n}}\z/] #=> "tring"

0

我发现str.delete(str[0])它的可读性是一个不错的解决方案,尽管我不能证明它的性能。

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.