Is $string =~ s/^/$prefix/; about the same speed as the substr expression?

To me, it would more signal the intent than substr does. Then again, so does the pesky dot-between-strings notation, which 1nickt doesn't want. :-) But, as with the substr, the =~ s/^// version doesn't require duplicating $string in your statement, which is one of the benefits of the suffixing .= operator.

Here's the benchmark code:
Read more... (1071 Bytes)

Here's the result on my machine:

ok 1 - correct concat
ok 2 - same substr
ok 3 - same subst
1..3
            Rate  subst precat substr
subst  1770916/s     --   -38%   -47%
precat 2860656/s    62%     --   -15%
substr 3350927/s    89%    17%     --
[download]

($q=q:Sq=~/;[c](.)(.)/;chr(-||-|5+lengthSq)`"S|oS2"`map{chr |+ord
}map{substrSq`S_+|`|}3E|-|`7**2-3:)=~y+S|`+$1,++print+eval$q,q,a,
[download]

The results are even more dramatic if you do away with some of the dogma.

The overhead of the subroutine calls may be a constant; but it is sufficiently large that it obscures the real differences. Particularly the dramatic cost of using subst for such trivial operations:

#!/usr/bin/perl
use warnings;
use strict;

our $TEST //= 0;

use Benchmark qw{ cmpthese };

sub precat {
    my ($string, $prefix) = @_;
    $string = $prefix . $string;
    $string
}

sub Substr {
    my ($string, $prefix) = @_;
    substr $string, 0, 0, $prefix;
    $string
}

sub subst {
    my ($string, $prefix) = @_;
    $string =~ s/^/$prefix/;
    $string
}

sub pc(\$@){        ${$_[0]} = $_[1] . ${$_[0]}; }
sub sr(\$@){ substr ${$_[0]}, 0, 0, $_[1]; }
sub st(\$@){        ${$_[0]} =~ s[^][$_[1]]; }


cmpthese -1, {
    precat1 => q( precat 'def', 'abc' ),
    substr1 => q( Substr 'def', 'abc' ),
    subst1  => q( subst  'def', 'abc' ),

    precat2 => q( my $r = 'def'; pc $r, 'abc'; ),
    substr2 => q( my $r = 'def'; sr $r, 'abc'; ),
    subst2  => q( my $r = 'def'; st $r, 'abc'; ),

    precat3 => q( my $r = 'def'; $r = 'abc' . $r; ),
    substr3 => q( my $r = 'def'; substr $r, 0, 0, 'abc'; ),
    subst3  => q( my $r = 'def'; $r =~ s[^][abc]; ),
};

__END__
             Rate subst2 subst1 subst3 precat1 precat2 substr1 precat3
+ substr2 substr3
subst2   338979/s     --   -40%   -46%    -61%    -73%    -74%    -77%
+    -78%    -91%
subst1   563106/s    66%     --   -10%    -35%    -55%    -57%    -61%
+    -63%    -85%
subst3   625570/s    85%    11%     --    -28%    -50%    -52%    -57%
+    -59%    -84%
precat1  863641/s   155%    53%    38%      --    -31%    -34%    -40%
+    -44%    -77%
precat2 1242736/s   267%   121%    99%     44%      --     -6%    -14%
+    -19%    -67%
substr1 1315147/s   288%   134%   110%     52%      6%      --     -9%
+    -14%    -66%
precat3 1442465/s   326%   156%   131%     67%     16%     10%      --
+     -6%    -62%
substr2 1537398/s   354%   173%   146%     78%     24%     17%      7%
+      --    -60%
substr3 3816524/s  1026%   578%   510%    342%    207%    190%    165%
+    148%      --
[download]

---

With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority". I knew I was on the right track :)

In the absence of evidence, opinion is indistinguishable from prejudice.

Below, benchmarked the same 3 functions with minimal variable declaration.

use warnings;
use strict;

use Benchmark qw{ cmpthese };

# original code by choroba

sub precat {
    my ($string, $prefix) = @_;
    $string = $prefix . $string;
    $string
}
sub Substr {
    my ($string, $prefix) = @_;
    substr $string, 0, 0, $prefix;
    $string
}
sub subst {
    my ($string, $prefix) = @_;
    $string =~ s/^/$prefix/;
    $string
}

# minimal variable declaration

sub precatm {
    $_[1] . $_[0];
}
sub Substrm {
    substr my $string = $_[0], 0, 0, $_[1];
    $string;
}
sub substm {
    ( my $string = $_[0] ) =~ s/^/$_[1]/;
    $string;
}

cmpthese -1, {
    precat  => q( precat  'def', 'abc' ),
    substr  => q( Substr  'def', 'abc' ),
    subst   => q( subst   'def', 'abc' ),

    precatm => q( precatm 'def', 'abc' ),
    substrm => q( Substrm 'def', 'abc' ),
    substm  => q( substm  'def', 'abc' ),
};
[download]

Results from a 2.6 GHz Core i7 CPU:

             Rate   subst  substm  precat  substr substrm precatm
subst   2104367/s      --    -10%    -29%    -48%    -61%    -72%
substm  2338582/s     11%      --    -21%    -43%    -57%    -69%
precat  2969268/s     41%     27%      --    -27%    -45%    -61%
substr  4071762/s     93%     74%     37%      --    -25%    -46%
substrm 5397081/s    156%    131%     82%     33%      --    -29%
precatm 7561845/s    259%    223%    155%     86%     40%      --
[download]