blocks|key|1154951|text|与上面Pablo的答案类似，但是一个遮阳板清洁剂：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1154952|str[1..-1]|code-block|syntax|javascript|1154953|将返回从1到最后一个字符的数组。|1154954|'Hello+World'[1..-1]
+=>+"ello+World"|1154955|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Similar to Pablo's answer above, but a shade cleaner :

<pre><code>str[1..-1]
</code></pre>

Will return the array from 1 to the last character.

<pre><code>'Hello World'[1..-1]
 =&gt; "ello World"
</code></pre>

blocks|key|940800|text|我们可以使用slice来做到这一点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|940801|val+=+"abc"
+=>+"abc"+
val.slice!(0)
+=>+"a"+
val
+=>+"bc"+|code-block|syntax|javascript|940802|使用slice!，我们可以通过指定其索引来删除任何字符。|offset|length|style|CODE|940803|entityMap^0|0|0|2|6|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

We can use slice to do this:

<pre><code>val = "abc"
 =&gt; "abc" 
val.slice!(0)
 =&gt; "a" 
val
 =&gt; "bc" 
</code></pre>

Using <code>slice!</code> we can delete any character by specifying its index.

blocks|key|940860|text|我更喜欢这样：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|940861|str+=+"[12,23,987,43"
puts+str[1..-1]
>>+12,23,987,43|code-block|syntax|javascript|940862|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I prefer this:

<pre><code>str = "[12,23,987,43"
puts str[1..-1]
&gt;&gt; 12,23,987,43
</code></pre>

blocks|key|940587|text|如果您总是想去掉前导括号：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|940588|"[12,23,987,43".gsub(/%5E\[/,+"")|code-block|syntax|javascript|940589|如果您只想删除第一个字符，并且您知道它不会在多字节字符集中：|940590|"[12,23,987,43"[1..-1]|940591|或|940592|"[12,23,987,43".slice(1..-1)|940593|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

If you always want to strip leading brackets:

<pre><code>"[12,23,987,43".gsub(/^\[/, "")
</code></pre>

If you just want to remove the first character, and you know it won't be in a multibyte character set:

<pre><code>"[12,23,987,43"[1..-1]
</code></pre>

or

<pre><code>"[12,23,987,43".slice(1..-1)
</code></pre>

blocks|key|940914|text|低效的替代方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|940915|str.reverse.chop.reverse|code-block|syntax|javascript|940916|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Inefficient alternative: 

<pre><code>str.reverse.chop.reverse
</code></pre>

blocks|key|1155027|text|例如:a=“一二三”|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1155028|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"+|code-block|syntax|javascript|1155029|这样，您就可以逐个删除字符串的第一个字符。|1155030|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

For example : a = "One Two Three"

<pre><code>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" 
</code></pre>

In this way you can remove one by one first character of the string.

blocks|key|940508|text|简单的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|940509|str+=+"[12,23,987,43"

removed+=+str[1..str.length]|code-block|syntax|javascript|940510|很棒的方式：|940511|class+String
++def+reverse_chop()
++++self[1..self.length]
++end
end

"[12,23,987,43".reverse_chop()|940512|(注意:更喜欢简单的方式:)|940513|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Easy way:

<pre><code>str = "[12,23,987,43"

removed = str[1..str.length]
</code></pre>

Awesome way:

<pre><code>class String
 def reverse_chop()
 self[1..self.length]
 end
end

"[12,23,987,43".reverse_chop()
</code></pre>

(Note: prefer the easy way :) )

blocks|key|1155122|text|感谢@+the+-tin-man把基准放在一起！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1155123|遗憾的是，我真的不喜欢这些解决方案。要么他们需要额外的步骤来获得结果([0]+=+''，.strip!)，要么他们对发生的事情语义不是很清楚([1..-1]："Um，从1到负1?+Yearg?")，或者他们写出来很慢或者很长(.gsub，.length)。|offset|length|style|CODE|1155124|我们尝试的是一个“移位”(数组术语)，但是返回剩余的字符，而不是移位掉的字符。让我们使用Ruby通过字符串来实现这一点！我们可以使用快速的括号操作，但要给它一个好的名称，并使用一个arg来指定我们想要从前面去掉多少：|1155125|class+String
++def+eat!(how_many+=+1)
++++self.replace+self[how_many..-1]
++end
end|code-block|syntax|javascript|1155126|但是，我们可以使用这种快速但笨拙的括号操作做更多的事情。同时，为了完整起见，让我们为String编写一个#shift和#first+(为什么数组应该拥有所有有趣的‽‽)，使用一个arg来指定我们想要从开头删除多少个字符：|1155127|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|1155128|好了，现在我们有了一个很好的清晰的方法来从字符串的前面拉出字符，方法是与Array#first和Array#shift一致的(这真的应该是一个很棒的方法吗？)我们也可以用#eat!很容易地得到修改后的字符串。嗯，我们应该和数组分享我们新的eat!功能吗？好呀!|1155129|class+Array
++def+eat!(how_many+=+1)
++++self.replace+self[how_many..-1]
++end
end|1155130|现在我们可以：|1155131|>+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]+|1155132|那好多了!|1155133|entityMap^0|0|Z|8|18|7|1Z|7|35|5|3B|7|0|0|0|1G|6|1N|6|0|0|10|B|1C|B|2D|5|3B|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@$D|16|E|17|F|G]|$D|18|E|19|F|G]|$D|1A|E|1B|F|G]|$D|1C|E|1D|F|G]|$D|1E|E|1F|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1G|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1H|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1I|8|@$D|1J|E|1K|F|G]|$D|1L|E|1M|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1N|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1O|8|@$D|1P|E|1Q|F|G]|$D|1R|E|1S|F|G]|$D|1T|E|1U|F|G]|$D|1V|E|1W|F|G]]|9|@]|A|$]]|$1|U|3|V|5|L|7|1X|8|@]|9|@]|A|$M|N]]|$1|W|3|X|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|L|7|1Z|8|@]|9|@]|A|$M|N]]|$1|10|3|11|5|6|7|20|8|@]|9|@]|A|$]]|$1|12|3|-4|5|6|7|21|8|@]|9|@]|A|$]]]|13|$]]

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 (<code>[0] = ''</code>, <code>.strip!</code>) or they aren't very semantic/clear about what's happening (<code>[1..-1]</code>: "Um, a range from 1 to negative 1? Yearg?"), or they are slow or lengthy to write out (<code>.gsub</code>, <code>.length</code>).

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: 

<pre><code>class String
 def eat!(how_many = 1)
 self.replace self[how_many..-1]
 end
end
</code></pre>

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 <code>#shift</code> and <code>#first</code> for String (why should Array have all the fun‽‽), taking an arg to specify how many characters we want to remove from the beginning:

<pre><code>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
</code></pre>

Ok, now we have a good clear way of pulling characters off the front of a string, with a method that is consistent with <code>Array#first</code> and <code>Array#shift</code> (which really should be a bang method??). And we can easily get the modified string as well with <code>#eat!</code>. Hm, should we share our new <code>eat!</code>ing power with Array? Why not!

<pre><code>class Array
 def eat!(how_many = 1)
 self.replace self[how_many..-1]
 end
end
</code></pre>

Now we can:

<pre><code>&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] 
</code></pre>

That's better!

blocks|key|940599|text|str+=+"[12,23,987,43"

str[0]+=+""|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|940600|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

blocks|key|1155202|text|class+String
++def+bye_felicia()
++++felicia+=+self.strip[0]+#first+char,+not+first+space.
++++self.sub(felicia,+'')
++end
end|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1155203|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>class String
 def bye_felicia()
 felicia = self.strip[0] #first char, not first space.
 self.sub(felicia, '')
 end
end
</code></pre>

blocks|key|940943|text|使用正则表达式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|940944|str+=+'string'
n+=+1++#to+remove+first+n+characters

str[/.{#{str.size-n}}\z/]+#=>+"tring"|code-block|syntax|javascript|940945|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Using regex:

<pre><code>str = 'string'
n = 1 #to remove first n characters

str[/.{#{str.size-n}}\z/] #=&gt; "tring"
</code></pre>

blocks|key|1155242|text|我发现一个很好的解决方案是str.delete(str[0])，因为它的可读性，尽管我不能证明它的性能。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1155243|entityMap^0|D|I|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

I find a nice solution to be <code>str.delete(str[0])</code> for its readability, though I cannot attest to it's performance.

Example:

<pre><code>[12,23,987,43
</code></pre>

What is the fastest, most efficient way to remove the "<code>[</code>",
using maybe a <code>chop()</code> but for the first character?

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

示例：[12,23,987,43删除"[“的最快、最有效的方法是什么，可能是使用chop()，但第一个字符？

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

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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