문자열에서 첫 번째 문자를 제거하는 가장 쉬운 방법은 무엇입니까?
예:
[12,23,987,43
"을(를) 제거하는 가장 빠르고 효율적인 방법은 무엇입니까?[아마도 a를 사용하여chop()하지만 첫 번째 캐릭터는?
위의 파블로의 대답과 비슷하지만 그늘막 청소기:
str[1..-1]
배열을 1에서 마지막 문자로 반환합니다.
'Hello World'[1..-1]
=> "ello World"
저는 다음과 같은 것을 사용하는 것을 선호합니다.
asdf = "[12,23,987,43"asdf[0] = '' 파스디프# >> "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하위 문자열 검색보다 훨씬 느리게 일치하는 잘못 작성된 정규식도 장애가 될 수 있습니다.가능하면 정규식을 고정하여 최대 속도를 얻습니다.스택 오버플로에 대한 답변이 있으므로 자세한 내용을 보려면 검색하십시오.
슬라이스를 사용하여 다음 작업을 수행할 수 있습니다.
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"
N.B. 또한 문자열의 끝에서 항목을 제거하는 데 사용할 수 있습니다.delete_suffix그리고.delete_suffix!
'worked'.delete_suffix('ed') #=> "work"
'medical'.delete_suffix('ed') #=> "medical"
편집:
틴 맨의 벤치마크 설정을 사용하면 상당히 빨라 보입니다(마지막 두 항목 아래).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
항상 선행 브래킷을 제거하려는 경우:
"[12,23,987,43".gsub(/^\[/, "")
첫 번째 문자만 제거하고 멀티바이트 문자 집합에 포함되지 않을 경우:
"[12,23,987,43"[1..-1]
또는
"[12,23,987,43".slice(1..-1)
비효율적인 대안:
str.reverse.chop.reverse
쉬운 방법:
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()
(참고: 쉬운 방법을 선호합니다 :)
예: 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"
이렇게 하면 문자열의 첫 번째 문자를 하나씩 제거할 수 있습니다.
벤치마크를 작성해 준 @the-tin-man에게 감사드립니다!
아아, 저는 그 어떤 해결책도 별로 좋아하지 않습니다.결과를 얻으려면 추가 단계가 필요합니다([0] = '',.strip!) 또는 그들은 무슨 일이 일어나고 있는지에 대해 매우 의미적/명확하지 않습니다([1..-1]1?"이고, 1은 1이고, 1은 1입니까?(yearg?), 또쓰느나길거나리거가기는(길나▁year거()..gsub,.length).
우리가 시도하는 것은 'shift'(어레이 용어로)이지만, 꺼진 문자가 아닌 나머지 문자를 반환하는 것입니다.우리 루비를 사용해서 끈으로 이것을 가능하게 해요!우리는 빠른 브래킷 작동을 사용할 수 있지만, 좋은 이름을 붙이고 앞에서 얼마나 잘라내고 싶은지 지정하기 위해 Arg를 사용합니다.
class String
def eat!(how_many = 1)
self.replace self[how_many..-1]
end
end
하지만 우리가 할 수 있는 일이 더 많습니다. 신속하지만 다루기 힘든 브래킷 작업입니다.우리가 그것을 하는 동안, 완성도를 위해, 다음과 같이 쓰자.#shift그리고.#firstString(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그리고.Array#shift( 느것이 정쾅합방까니야어이법는 된 문자열은 ? 수 있습니다. 그리고 우리는 수정된 문자열도 쉽게 얻을 수 있습니다.#eat!흠, 우리의 새로운 것을 공유할까요?eat!어레이로 전력을 공급하시겠습니까?당연하죠!
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]
그게 더 낫군요!
str = "[12,23,987,43"
str[0] = ""
class String
def bye_felicia()
felicia = self.strip[0] #first char, not first space.
self.sub(felicia, '')
end
end
정규식 사용:
str = 'string'
n = 1 #to remove first n characters
str[/.{#{str.size-n}}\z/] #=> "tring"
을 찾습니다.str.delete(str[0])가독성 때문에, 성능을 증명할 수는 없지만요.
list = [1,2,3,4] list.drop(1)
# => [2,3,4]
목록은 배열의 시작 부분에서 하나 이상의 요소를 삭제하고 배열을 변환하지 않으며 삭제된 요소 대신 배열 자체를 반환합니다.
언급URL : https://stackoverflow.com/questions/3614389/what-is-the-easiest-way-to-remove-the-first-character-from-a-string
'programing' 카테고리의 다른 글
| TypeError: 정의되지 않은 속성을 읽을 수 없습니다('html' 읽기). (0) | 2023.06.02 |
|---|---|
| 로드 시 Ruby on Rails 콘솔이 중단됨 (0) | 2023.06.02 |
| ios app 최대 메모리 예산 (0) | 2023.06.02 |
| 루비 스크립트를 디버깅하는 방법 (0) | 2023.06.02 |
| 아이폰 앱 마이너스 앱스토어? (0) | 2023.06.02 |