# updated, thanks to PerlMouse -- not using \b, though!
$str =~ s/(^|,)42(,|$)/$1 && $2/e
[download]

You ought to guard the 42 with \b's on both sides, or it will turn 130,1423,999 into 130,13,999.
Perl --((8:>*

Hi,
sorry, but just for me to understand:


$1 && $2
[download]

means: if both are there, return the latest, in this case $2?
Like this:

perl -e'$a=1;$b=2;print ($a && $b)'
[download]

Thanks,
svenXY

It's a trick, I'll admit. In Perl, && returns the right-hand operand if the left-hand one is true, and the left-hand operand if the left-hand one is false. X && Y returns X if X is false, and Y if X is true (regardless of Y's truth value!).

Thus, in my regex, a comma is only inserted if both $1 and $2 are true. $1 && $2 is only true when $1 and $2 have commas in them (otherwise, at least one of them is empty, and thus the empty string is returned).

---

Jeff japhy Pinyan, P.L., P.M., P.O.D, X.S.: Perl, regex, and perl hacker
How can we ever be the sold short or the cheated, we who for every service have long ago been overpaid? ~~ Meister Eckhart

I'm currently doing this in .NET C# (which you couldn't know), where i can't eval like that, so a regex substitution /$1$2/ would eat both commas, like

   "41,42,43" -> "4143"
[download]

Any plain vanilla regex to do it ?
/allan

s/(,42\b|\b42,|^42$)//g;
[download]

s/(,42|42,)//g;

The problem with this is that a list, by definition, might contain only one element. What if that element is 42?

s/(,42|42,|\b42\b)//g;

Tricky, isn't? Unfortunally, you still haven't cover all cases correctly:

    $ perl -wle '$_ = "142,143"; s/(,42|42,|\b42\b)//g; print'
    1143
[download]

You need to anchor all cases:

    s/,42\b|\b42,|^42$//;   # Or
    s/\b(?:,42|42,|42)\b//; # Or
    s/\b42,|,?42\b//;
[download]

Perl --((8:>*

Yeah, and painful. Although it can be done it regex, it just goes to show why I would much rather iterate through a list and process each element individually instead of handling all the element special cases in a regex. From a processing efficiency standpoint I'm not sure which is better, but I think regarding a programmer's efficiency, and future understanding, I'd lean toward looping through a list and handling each element on its own as a better decision. It just seems cleaner to me (as fun as regex exercises are); but maybe that's just me.

-jbWare

That wouldn't work on a list containing just '42'. It will the string unmodified instead of ending up with the empty string.
Perl --((8:>*

    s/\b42\b,?// && s/,$//;
[download]

    join ",", grep {$_ != 42} split /,/, $string
[download]

I'd much prefer one plain vanilla regex (w/o Perl /e magic), so does such a beast exist...?
/allan

Just by listing all cases.

    s/,42\b|\b42,|^42$//
[download]

But next time, ask VB questions on a VB forum.
Perl --((8:>*

for ("42,43", "41,42", "41,42,43", "41,142,423") {
  print "$_ \t=> ";
  my $string = $_;
  $string =~ s/(
                ((?=,)|^)42(,|$)
                 |
                (,|^)42((?=,)|$)
               )
              //xg;
  print "$string\n";
}

__OUTPUT__
42,43        => 43
41,42        => 41
41,42,43     => 41,43
41,142,423   => 41,142,423
[download]

  s/,42(?=,)|,?\b42\b,?//g;
[download]

((?=,*\s*42))(,\s*42|42\s*,|\s*42\s*)((?<=42\s*,*))
[download]

((?=,*\s*42))(,\s*42|42\s*,|\s*42\s*)((?<=42\s*,*))

Being left with a result, which is not applicable in Perl isn't satisfying either. (There is no variable length lookbehind in Perl.)

I tried to understand your regex without being able to test it (as given) in Perl. But I either did not get it, or it is still incomplete, as I have the impression, that a string like before,42XX,after will be reduced to beforeXX,after after applying your regex and substituting the match to empty??

Anyway, I would suggest to use the regex provided by reasonablekeith earlier, because it seems to cover all cases correctly.

Stripping enclosing whitespace is easily achieved with this too, by adjusting 42 to \s*42\s* (twice) in that regex.

Well the regex did do the job in .NET (using $1$3 as replacement) on lists of the indicated type, like:

   "42,43"    ->  "43"
   "41,42"    ->  "41"
   "41,42,43" ->  "41,43"
[download]

That is: "42,15,42,173,42" will be reduced to "15,173", which was basically what I wanted. And yes, "before,42XX,after" will be reduced to "beforeXX,after", but that was not the kind of data I needed to manipulate in this case.

You can try out .NET regexes by installing the runtime plus a tool like RegexDesigner.

Update
And you're right: the regex by reasonablekeith above does the same, but will leave "before,42XX,after" intact (if that's what you want); His regex is shorter tho', and could be preferred for that reason, -- but it is not forgiving with resp. to whitespace around the numbers, ie. "23,42 ,45, 56,42" will be reduced to "23,42 ,45, 56".

Best regards,
Allan Dystrup

Complicated. And I'm surprised - it seems that .NET/C# implements variable width look behind, something that Perl doesn't do.
Perl --((8:>*

Check this : .NET RegEx
Best Regards
Allan

$_ = join ',', grep { $_ ne '42' } split ',';
[download]