Какой самый эффективный способ удалить первый символ строки?

Ответ 1

Используйте slice!:

s = "Hello"
s.slice!(0) #=> "ello"

Попробуйте в irb:

ruby-1.9.3-p0 :001 > s = "Hello"
 => "Hello" 
ruby-1.9.3-p0 :002 > s.slice!(0) #=> "ello"
 => "H" 
ruby-1.9.3-p0 :003 > s
 => "ello" 

Ответ 2

Лучшее решение будет "foobar"[1..-1]. Нет необходимости в регулярном выражении.

Ответ 3

Говоря об эффективности, у меня никогда не было хорошей возможности играть с модулем ruby ​​ Benchmark, поэтому решил сделать это из любопытства прямо сейчас. Здесь контрольный показатель:

require 'benchmark'

n = 10_000_000

s = 'c1234'

Benchmark.bm(8) do |x|
  x.report('slice!')  { n.times { s.dup.slice!(0) } }
  x.report('slice')   { n.times { s.dup.slice(1, 4) } }
  x.report('[1..-1]') { n.times { s.dup[1..-1] } }
  x.report('[1..4]')  { n.times { s.dup[1..4] } }
  x.report('reverse') { n.times { s.dup.reverse.chop.reverse } }
  x.report('gsub')    { n.times { s.dup.gsub(/^./, "") } }
  x.report('sub')     { n.times { s.dup.sub(/^./, "") } }
end

И есть результаты:

              user     system      total        real
slice!    7.460000   0.000000   7.460000  (7.493322)
slice     6.880000   0.000000   6.880000  (6.902811)
[1..-1]   7.710000   0.000000   7.710000  (7.728741)
[1..4]    7.700000   0.000000   7.700000  (7.717171)
reverse  10.130000   0.000000  10.130000 (10.151716)
gsub     11.030000   0.000000  11.030000 (11.051068)
sub       9.860000   0.000000   9.860000  (9.880881)

Кажется, что slice - лучший выбор с наиболее очевидным (по крайней мере для меня) s[1..-1] или s[1..4] немного позади. И решения с reverse и regexp выглядят сложными для такого рода задач.

Ответ 4

Вариант 1:

"abcd"[1..-1]

Вариант 2 (более описательный):

"abcd".last(-1)

Ответ 5

Существует несколько способов сделать это:)

"foobar".gsub(/^./, "")  # => "oobar"

Ответ 6

Я принимал решения до сих пор и составил критерий:

require 'benchmark'

#~ TEST_LOOPS = 10_000_000
TEST_LOOPS = 10_000
TESTSTRING = 'Hello'

Benchmark.bmbm(10) {|b|

  b.report('slice!') {    
   TEST_LOOPS.times { 
      s = TESTSTRING.dup
      s.slice!(0)
   }            #Testloops
  }             #b.report

  b.report('gsub^') {    
   TEST_LOOPS.times { 
      s = TESTSTRING.dup
      s.gsub(/^./, "")
   }            #Testloops
  }             #b.report


  b.report('gsub\A') {    
   TEST_LOOPS.times { 
      s = TESTSTRING.dup
      s.gsub(/\A./, "")
   }            #Testloops
  }             #b.report

  b.report('[1..-1]') {    
   TEST_LOOPS.times { 
      s = TESTSTRING.dup
      s = s[1..-1]
   }            #Testloops
  }             #b.report

  b.report('s[0] = ""') {    
   TEST_LOOPS.times { 
      s = TESTSTRING.dup
      s[0] = ''
   }            #Testloops
  }             #b.report

  b.report('reverse.chop') {    
   TEST_LOOPS.times { 
      s = TESTSTRING.dup
      s = s.reverse.chop.reverse
   }            #Testloops
  }             #b.report
} #Benchmark

Результат:

Rehearsal ------------------------------------------------
slice!         0.000000   0.000000   0.000000 (  0.000000)
gsub^          0.063000   0.000000   0.063000 (  0.062500)
gsub\A         0.031000   0.000000   0.031000 (  0.031250)
[1..-1]        0.000000   0.000000   0.000000 (  0.000000)
s[0] = ""      0.015000   0.000000   0.015000 (  0.015625)
reverse.chop   0.016000   0.000000   0.016000 (  0.015625)
--------------------------------------- total: 0.125000sec

                   user     system      total        real
slice!         0.016000   0.000000   0.016000 (  0.015625)
gsub^          0.046000   0.000000   0.046000 (  0.046875)
gsub\A         0.032000   0.000000   0.032000 (  0.031250)
[1..-1]        0.015000   0.000000   0.015000 (  0.015625)
s[0] = ""      0.016000   0.000000   0.016000 (  0.015625)
reverse.chop   0.016000   0.000000   0.016000 (  0.015625)

По крайней мере, регулярные выражения не должны использоваться.

Ответ 7

Если вы используете ruby ​​1.9:

s = "foobar"
s[0] = ''