[ruby] 문자열에서 첫 번째 문자를 제거하는 가장 쉬운 방법은 무엇입니까?
예:
[12,23,987,43첫 번째 문자를 [사용하여 ” ” 를 제거하는 가장 빠르고 효율적인 방법은 무엇입니까 chop()?
답변
다음과 같은 것을 사용하는 것이 좋습니다.
asdf = "[12,23,987,43" asdf [0] = '' p asdf # >> "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또한 하위 문자열 검색보다 훨씬 더 느리게 일치 잘못 작성된 정규식에 의해 장애인 수 있습니다. 가능한 경우 정규 표현식을 고정하여 가장 빠른 속도를 얻으십시오. 여기에 스택 오버플로에 대한 답변이 있으므로 추가 정보를 원하면 검색하십시오.
답변
위의 Pablo의 대답과 비슷하지만 그늘 청소기 :
str[1..-1]배열을 1에서 마지막 문자로 반환합니다.
'Hello World'[1..-1]
=> "ello World"답변
슬라이스를 사용하여이를 수행 할 수 있습니다.
val = "abc"
=> "abc"
val.slice!(0)
=> "a"
val
=> "bc" 사용하여 slice!색인을 지정하여 모든 문자를 삭제할 수 있습니다.
답변
루비 2.5 이상
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!) 매우 빠릅니다 . 하지 않습니다 매우 하지만, 속도에 대한 이전의 제품 구입에 PIP 매우 읽을 수 있습니다.
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답변
항상 선행 대괄호를 제거하려는 경우 :
"[12,23,987,43".gsub(/^\[/, "")첫 번째 문자 만 제거하고 멀티 바이트 문자 집합이 아닌 경우 :
"[12,23,987,43"[1..-1]또는
"[12,23,987,43".slice(1..-1)답변
비효율적 인 대안 :
str.reverse.chop.reverse