I remember many times I searched for a better way to "remove all
occurrence of matches on a String".
I usually do:
str.gsub! /\bword\b/, ''
I remembered the String#[]= from tryruby.org, but that only replace
the first occurrence.
String#delete "Uses the same rules for building the set of characters
as String#count", and does not work with Regexp.
String#tr follow the same rules, and would need a second '' parameter.
What feels a bit "awkward" to me in the first approach is to specify I
want no replacement (so nothing, so I should not have to specify it).
I think for a default second parameter to (g)sub(!) (without block),
but this case is supposed to return an Enumerator (is it sometimes
useful?).
Also the "sub" part of the name clearly indicate it is substituting
sth for a new thing (the new thing should not be empty).
I would then go for #delete, adding a special case for RegExp
arguments, but that is not consistent with current behavior with a
String.
However, String#delete seems very rarely used, and could get some
interest back. (and "str".delete(/\bword\b/) do feel right to me)
I think gsub with an empty string is ugly too, but I am pretty confident
there is not a better way.
You need to be careful, though, delete and tr don't work the way you think
they work. They are based on characters not words. They don't work with
regex because they consider the input string to be a set of characters, and
that doesn't make sense with regex.
On Sat, Oct 9, 2010 at 9:09 AM, Benoit Daloze <eregontp@gmail.com> wrote:
Hi Rubyists !
I remember many times I searched for a better way to "remove all
occurrence of matches on a String".
I usually do:
str.gsub! /\bword\b/, ''
I remembered the String#= from tryruby.org, but that only replace
the first occurrence.
String#delete "Uses the same rules for building the set of characters
as String#count", and does not work with Regexp.
String#tr follow the same rules, and would need a second '' parameter.
What feels a bit "awkward" to me in the first approach is to specify I
want no replacement (so nothing, so I should not have to specify it).
I think for a default second parameter to (g)sub(!) (without block),
but this case is supposed to return an Enumerator (is it sometimes
useful?).
Also the "sub" part of the name clearly indicate it is substituting
sth for a new thing (the new thing should not be empty).
I would then go for #delete, adding a special case for RegExp
arguments, but that is not consistent with current behavior with a
String.
However, String#delete seems very rarely used, and could get some
interest back. (and "str".delete(/\bword\b/) do feel right to me)
Don't waste too much thought on this. After all the second parameter makes it clear what's happening here. My 0.02 EUR.
Cheers
robert
···
On 09.10.2010 16:09, Benoit Daloze wrote:
Hi Rubyists !
I remember many times I searched for a better way to "remove all
occurrence of matches on a String".
I usually do:
str.gsub! /\bword\b/, ''
I remembered the String#= from tryruby.org, but that only replace
the first occurrence.
String#delete "Uses the same rules for building the set of characters
as String#count", and does not work with Regexp.
String#tr follow the same rules, and would need a second '' parameter.
What feels a bit "awkward" to me in the first approach is to specify I
want no replacement (so nothing, so I should not have to specify it).
I think for a default second parameter to (g)sub(!) (without block),
but this case is supposed to return an Enumerator (is it sometimes
useful?).
Also the "sub" part of the name clearly indicate it is substituting
sth for a new thing (the new thing should not be empty).
I would then go for #delete, adding a special case for RegExp
arguments, but that is not consistent with current behavior with a
String.
However, String#delete seems very rarely used, and could get some
interest back. (and "str".delete(/\bword\b/) do feel right to me)
I think gsub with an empty string is ugly too, but I am pretty confident
there is not a better way.
So I am not the only to think that
You need to be careful, though, delete and tr don't work the way you think
they work. They are based on characters not words. They don't work with
regex because they consider the input string to be a set of characters, and
that doesn't make sense with regex.
Yes, I know, I proposed to add some functionality to #delete.
I would then go for #delete, adding a special case for RegExp
arguments, but that is not consistent with current behavior with a String.
That is indeed a consistence issue.
However, the semantic of "delete" (in general) seems right to me to
delete/remove a part of a String (and I think is makes even more sense
than the current implementation which does tr(str,'')).
···
On 10 October 2010 03:39, Josh Cheek <josh.cheek@gmail.com> wrote:
