Make copies and pass them in instead.

This is as easy as just passing "$1" instead of $1.

The general rule is never, ever pass in $1 and its friends, as they're terribly ephemeral. Make copies and pass them in instead.

That's a good general rule but I'd still go for belt and braces.

If the API of a function doesn't say it treats its arguments as lvalues then it is good practice to make copies of the elements from @_. If you need to do any regex processing before you unpack @_ then wrap it in a block.

As Elian says, make copies when passing in ephemeral values such as $1, $!, $@; one easy way to do that is to stringify, as long as that doesn't lose you information:

  $person->name("$1");
[download]

If just the string is not enough (eg to pass the dualvar $!), I think the easiest way is to make a copy:

  my $error = $!;
  $log->error($error);
[download]

Hugo

Aha! But what if you don't want to create a lexical variable that lives any longer than necessary? Well, you could use a bare block:

    {
      my $error = $!;
      $log->error($error)
    }
[download]

But then what if you want the return value from the method? Well, you could use do:

    my $return = do { my $error = $!; $log->error($error) };
[download]

That's probably the sane way to handle it. But what if you're not sane? Then we can have some fun!

    my $return = $log->error(${ \(my $e = $!) });
[download]

Update: another fun way that never even makes the lexical variable:

    my $return = $log->error(@{[$!]});
[download]

Function parameters are passed by reference. This means @_ contained $1 which is modified by any successful regex. You can modify values in @_ directly to watch this.

Most of the time you aren't passing something like $1 in and don't have to worry about the issue you ran into