I could copy the sub into a new sub that implements basically the same functionality but with this small change.

Don't.  In the long run, and in the large scale, this will create a maintenance nightmare. For example, if you later realize that there's a bug in one of the copy-n-pasted common code fragments, or when you need to make some modification, you'll have to apply the fix/change in every place that same code appears...  Not only is this tedious, but experience has shown it is often not done properly, introducing new hard to track bugs.

See also the (more generally scoped) anti pattern Cut-And-Paste Programming.

sub doSomethingX {
    my $string = shift;
    $string =~ tr/foo/X/;
    return doSomething($string);
}

sub doSomethingY {
    my $string = shift;
    $string =~ tr/foo/Y/;
    return doSomething($string);
}

sub doSomething {
    my ($var) = shift;
    print $var;
}
[download]

It's a far to general question to be answered easily, could you show us some code?

> # I leave the if statements but then when you call a sub you can't really tell what it will return. As it can vary depending on what if's it might match.

I would suggest to write a wrapper¹ to this legacy code, controlling the state of these global flags

sub wrap_render {
  local $x=shift;
  local $y=shift;
  if ($var) {
    return "your change";
  } else
    return render();
  }
}
[download]

like this you have full control about this "alien" function.

As a general principle I prefer code to be easily understandable and avoid to clutter it with if statements which eventually turns the flow into a labyrinth. Furthermore I try to localize global vars as tight as possible.

So instead of something like

sub render_a {
  print "<a ";
  print "style='$css'" if $global_css_flag;
  print ">"
}
[download]

I would write something like

sub render_a {
  my $style=get_css();
  print "<a $style>";
}
 
{ my $css_flag;
  sub get_css {
    return "style='$css'" if $css_flag;
  }
  sub css_flag { if (@_) {$css_flag=shift} else {$css_flag} }  # gette
+r-setter
}
[download]

(untested)

UPDATE: added checking of new flag $var.

¹) in perl you can give the wrapper the same function name like the wrapped function you're calling from within! Just ask if you wanna go this way!

Sometimes the simplest code is still hairy.

You might be able to benefit from callbacks, e.g. changing

sub render {
   my ($self, $obj) = @_;
   ...
   ... if (...) { ... } else { ... } ...
   ...
}
[download]

sub render {
   my ($self, $obj) = @_;
   ...
   ... $obj->render_foo(...) ...
   ...
}
[download]