What is the easiest way to remove the first character from a string

Question

Example    12 23 987 43   What is the fastest  most efficient way to remove the      using maybe a chop   but for the first character

User · Answer

str     12 23 987 43   str 0

User · Answer

Inefficient alternative    str reverse chop reverse

User · Answer

Thanks to  the-tin-man for putting together the benchmarks    Alas  I don t really like any of those solutions  Either they require an extra step to get the result   0         strip   or they aren t very semantic clear about what s happening   1  -1    Um  a range from 1 to negative 1  Yearg     or they are slow or lengthy to write out   gsub   length    What we are attempting is a  shift   in Array parlance   but returning the remaining characters  rather than what was shifted off  Let s use our Ruby to make this possible with strings  We can use the speedy bracket operation  but give it a good name  and take an arg to specify how much we want to chomp off the front    class String   def eat  how many   1      self replace self how many  -1    end end   But there is more we can do with that speedy-but-unwieldy bracket operation  While we are at it  for completeness  let s write a  shift and  first for String  why should Array have all the fun     taking an arg to specify how many characters we want to remove from the beginning   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   Ok  now we have a good clear way of pulling characters off the front of a string  with a method that is consistent with Array first and Array shift  which really should be a bang method     And we can easily get the modified string as well with  eat   Hm  should we share our new eat ing power with Array  Why not   class Array   def eat  how many   1      self replace self how many  -1    end end   Now we can    gt  str     12 23 987 43     gt    12 23 987 43   gt  str eat                  gt   12 23 987 43   gt  str                      gt   12 23 987 43    gt  str eat  3               gt   23 987 43   gt  str                      gt   23 987 43    gt  str first 2              gt   23   gt  str                      gt   23 987 43    gt  str shift  3             gt   23    gt  str                      gt   987 43    gt  arr    1 2 3 4 5         gt   1  2  3  4  5    gt  arr eat                  gt   2  3  4  5    gt  arr                      gt   2  3  4  5     That s better

User · Answer

Ruby 2 5   As of Ruby 2 5 you can use delete prefix or delete prefix  to achieve this in a readable manner   In this case   12 23 987 43  delete prefix        More info here     Official docs https   blog jetbrains com ruby 2017 10 10-new-features-in-ruby-2-5  https   bugs ruby-lang org issues 12694    invisible  delete prefix  in      gt   visible   pink  delete prefix  in      gt   pink    N B  you can also use this to remove items from the end of a string with delete suffix and delete suffix    worked  delete suffix  ed      gt   work   medical  delete suffix  ed      gt   medical     Docs https   bugs ruby-lang org issues 13665   Edit   Using the Tin Man s benchmark setup  it looks pretty quick too  under the last two entries delete p and delete p    Doesn t quite pip the previous faves for speed  though is very readable   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

User · Answer

We can use slice to do this   val    abc     gt   abc   val slice  0     gt   a   val    gt   bc     Using slice  we can delete any character by specifying its index

User · Answer

Similar to Pablo s answer above  but a shade cleaner    str 1  -1    Will return the array from 1 to the last character    Hello World  1  -1     gt   ello World

User · Answer

For example    a    One Two Three   1 9 2-p290  gt  a    One Two Three     gt   One Two Three    1 9 2-p290  gt  a   a 1  -1     gt   ne Two Three    1 9 2-p290  gt  a   a 1  -1     gt   e Two Three    1 9 2-p290  gt  a   a 1  -1     gt    Two Three    1 9 2-p290  gt  a   a 1  -1     gt   Two Three    1 9 2-p290  gt  a   a 1  -1     gt   wo Three     In this way you can remove one by one first character of the string

User · Answer

I find a nice solution to be str delete str 0   for its readability  though I cannot attest to it s performance

User · Answer

list    1 2 3 4    list drop 1           gt   2 3 4    List drops one or more elements from the start of the array  does not mutate the array  and returns the array itself instead of the dropped element

User · Answer

class String   def bye felicia       felicia   self strip 0   first char  not first space      self sub felicia        end end

User · Answer

If you always want to strip leading brackets     12 23 987 43  gsub              If you just want to remove the first character  and you know it won t be in a multibyte character set     12 23 987 43  1  -1    or    12 23 987 43  slice 1  -1

User · Answer

Easy way   str     12 23 987 43   removed   str 1  str length    Awesome way   class String   def reverse chop       self 1  self length    end end    12 23 987 43  reverse chop      Note  prefer the easy way

User · Answer

Using regex   str    string  n   1   to remove first n characters  str      str size-n   z      gt   tring

User · Answer

I kind of favor using something like    asdf     12 23 987 43  asdf 0         p asdf       12 23 987 43      I m always looking for the fastest and most readable way of doing things   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   Running on my 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      Updating to incorporate one more suggested answer   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   Which results in   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      And another using      to find the first character   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   Which results in      gt  gt  2 1 5    gt  gt                user     system      total        real    gt  gt   0        0 270000   0 000000   0 270000    0 270165     gt  gt            0 430000   0 000000   0 430000    0 432417     gt  gt            0 460000   0 000000   0 460000    0 458221     gt  gt  sub       0 590000   0 000000   0 590000    0 590284     gt  gt  sub       0 590000   0 000000   0 590000    0 596366     gt  gt  gsub      1 880000   0 010000   1 890000    1 885892     gt  gt   1  -1    0 230000   0 000000   0 230000    0 223045     gt  gt  slice     0 300000   0 000000   0 300000    0 299175     gt  gt  length    0 320000   0 000000   0 320000    0 325841     gt  gt  eat       0 410000   0 000000   0 410000    0 409306     gt  gt  reverse   0 390000   0 000000   0 390000    0 393044      Here s another update on faster hardware and a newer version of 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         Why is gsub so slow    After doing a search replace  gsub has to check for possible additional matches before it can tell if it s finished  sub only does one and finishes  Consider gsub like it s a minimum of two sub calls    Also  it s important to remember that gsub  and sub can also be handicapped by poorly written regex which match much more slowly than a sub-string search  If possible anchor the regex to get the most speed from it  There are answers here on Stack Overflow demonstrating that so search around if you want more information

User · Answer

I prefer this   str     12 23 987 43  puts str 1  -1   gt  gt  12 23 987 43

[ruby] What is the easiest way to remove the first character from a string?

Examples related to ruby

Examples related to string