The for is apparently just being used as a topicalizer here. So if you rewrite the first code example in "normal" Perl, it's

if ( $sFunction =~ /test1/ ) {
    # ...
}
if ( $sFunction =~ /test2/ ) {
    # ...
}
[download]

So then it becomes more clear that one possibility of several for rewriting the logic is the following, where one could even consider to put $sFunction =~ /test2/ into a variable to avoid invoking the regex engine twice:

if ( $sFunction =~ /test1/ || $sFunction =~ /test2/ ) {
    # ...
    if ( $sFunction =~ /test2/ ) {
        # ...
    }
}
[download]

Or, assuming your regexes have something in common like these example regexes, you can even write something like:

if ( my ($num) = $sFunction =~ /test([12])/ ) {
    # ...
    if ( $num eq "2" ) {
        # ...
    }
}
[download]

AFAIS you are not using next at the end of each block, so there is no explicit fall-through

so one way is

for ( $sFunction ) {
    /test1/ || /test2/ and do {
        # ....
    };
    /test2/ and do {
        # will be executed too
    };
}
[download]

another way is to use a subroutine

my $do_test1 = sub { 
    #... 
};

for ( $sFunction ) {
    /test1/ && $do_test1->();

    /test2/ && do {
        $do_test1->();
        # will be executed too
    };
}
[download]

On a side note: why don't you use if or even if-elsif-else constructs?

I didn't wrote the script originally, so I can't say why they did it this way. I'm gonna try both versions to see if this does the trick for us. But yeah using subroutines would already help. Didn't thought about that, colleague just asked me for ideas. Right now there's not enough time for us to rewrite this script. This would be a good workaround for us.

G'day feumw,

With some realistic, example values for $sFunction, I may have provided a slightly different solution; however, in general, I'd probably tackle this with a dispatch table. Here's some example code showing the technique.

#!/usr/bin/env perl

use strict;
use warnings;

my %action_for;
%action_for = (
    test1 => sub {
        my ($input) = @_;
        print "*** Input: $input\n";
        print "Test 1 code\n"
    },
    test2 => sub {
        my ($input) = @_;
        $action_for{test1}->($input);
        print "Test 2 code\n";
    },
);

my @tests = qw{
    test1 test2 Atest1 test2B XYZ
    test1C test2D Etest1F Gtest2H
};

/(test\d)/ && $action_for{$1}->($_) for @tests;
[download]

Output:

*** Input: test1
Test 1 code
*** Input: test2
Test 1 code
Test 2 code
*** Input: Atest1
Test 1 code
*** Input: test2B
Test 1 code
Test 2 code
*** Input: test1C
Test 1 code
*** Input: test2D
Test 1 code
Test 2 code
*** Input: Etest1F
Test 1 code
*** Input: Gtest2H
Test 1 code
Test 2 code
[download]

Just wrap in a queue where you can add more things to the front. It does mean you will have to split some things into two parts, but still is just a fairly simple change.

#!/usr/bin/perl

use strict; # https://perlmonks.org/?node_id=11144894
use warnings;

my @functionqueue = @ARGV ? @ARGV : qw( test1 test2 test1 ); # FIXME

while( @functionqueue )
  {
  for ( shift @functionqueue ) {
    /test1/ && do {
        print "test1 stuff\n";
    };
    /test2/ && do {
        print "test2 stuff\n";
        unshift @functionqueue, qw( test1 secondpartof2 );
    };
    /secondpartof2/ && do {
        print "secondpartof2 stuff\n";
    };
    }
  }
[download]

Outputs:

test1 stuff
test2 stuff
test1 stuff
secondpartof2 stuff
test1 stuff
[download]

for ( $sFunction ) {
    (/test1/ || /test2/) && do {
        # ....
    };
    /test2/ && do {
        # ....
    };
}
[download]

Sorry, Same as LanX's first solution. Comments apply.