Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:67298
Mailing-List: contact internals-help@lists.php.net; run by ezmlm
Received-SPF: pass (pb1.pair.com: domain gmail.com designates 209.85.212.54 as permitted sender)
MIME-Version: 1.0
In-Reply-To: <CABBJUpf498q9epxACy=jFhxaxiFXYOSnVsSvk1qq8Bzg0oMjUQ@mail.gmail.com>
References: <CABBJUpd40Rnq=Ux5viXeNwkSDO2oUYgT+VznWtU0W-7ZDz5ChA@mail.gmail.com>
	<CABBJUpfZTiVH8AUNpknZC9y7uD4CP20KvuqtpZkVKfSDgRheAQ@mail.gmail.com>
	<CAF+90c94mJED9=6vqRAuZMYNfxt6YtcnEuCrhsy2Beh=uBNG9Q@mail.gmail.com>
	<CABBJUpfDgHHF8FaoC5=V9b70zHTKZKZheeCBQg3DWCPaWKuqkw@mail.gmail.com>
	<CAF+90c-zC7tHtB11Zv07ubHqBjKEj2tLninXA93BB5hjQngzfg@mail.gmail.com>
	<CABBJUpf498q9epxACy=jFhxaxiFXYOSnVsSvk1qq8Bzg0oMjUQ@mail.gmail.com>
Date: Sat, 4 May 2013 09:46:57 -0400
Message-ID: <CAAyV7nEsnMAwZstdFPaKCk-=eEdK-wLrq5JgnOy1-MDn+Ca4aQ@mail.gmail.com>
To: Laruence <laruence@php.net>
Cc: Nikita Popov <nikita.ppv@gmail.com>, PHP Internals <internals@lists.php.net>
Content-Type: multipart/alternative; boundary=047d7b675b2684c93a04dbe4b384
Subject: Re: [PHP-DEV] Re: [PROPOSAL]Add second to callback of preg_replace_callback
From: ircmaxell@gmail.com (Anthony Ferrara)

--047d7b675b2684c93a04dbe4b384
Content-Type: text/plain; charset=ISO-8859-1

Laruence,

> foreach ($replacements as $regex => $callback) {
> >     $str = preg_replace_callback($regex, $callback, $str);
> > }
> >
>
>  So if there are 10 regex in the array, you will got 10 DO_FCALL. 10 times
> arguments accept, 10 times etc...
>
>  and AS I already said: IT is inefficient. I personally can not accept it.
>
> thanks
>
>
My initial reaction was that the difference in runtime is going to be so
insignificant that it's the very definition of a micro-optimization between
the two. And unless you're doing it millions of times in a hot-loop, it's
never even going to be realized. I was going to reply to that effect.

Then I decided to write a quick test.

$count = 100;

$start = microtime(true);
for ($i = 0; $i < $count; $i++) {
    $str = "abc";
    $str = preg_replace_callback('/a/', function($a) { return
strtoupper($a[0]); }, $str);
  $str = preg_replace_callback('/b/', function($a) { return
strtoupper($a[0]); }, $str);
    $str = preg_replace_callback('/c/', function($a) { return
strtoupper($a[0]); }, $str);
    $str = preg_replace_callback('/a/', function($a) { return
strtolower($a[0]); }, $str);
    $str = preg_replace_callback('/b/', function($a) { return
strtolower($a[0]); }, $str);
    $str = preg_replace_callback('/c/', function($a) { return
strtolower($a[0]); }, $str);
}
echo "Completed in " . (microtime(true) - $start) . " Seconds\n";

$start = microtime(true);
for ($i = 0; $i < $count; $i++) {
    $str = "abc";
    $str = preg_replace(array(
          '/a/e',
            '/b/e',
            '/c/e',
            '/a/e',
            '/b/e',
            '/c/e',
        ),
        array(
            'strtoupper(\'$1\')',
            'strtoupper(\'$1\')',
            'strtoupper(\'$1\')',
            'strtolower(\'$1\')',
            'strtolower(\'$1\')',
            'strtolower(\'$1\')',
        ),
        $str
    );
}
echo "Completed in " . (microtime(true) - $start) . " Seconds\n";

So basically, it's comparing the old behavior (one call to preg_replace)
that you want to emulate, with what Nikita is suggesting.

I ran it on 3v4l (http://3v4l.org/dRjtU) and the results were quite
surprising. I was expecting the first to be slightly slower than the
second. But the reality surprised me:

Completed in 0.00076389312744141 Seconds Completed in 0.0012428760528564
Seconds

As it turns out, calling preg_replace_callback() multiple times is almost
50% faster than using a single call to preg_replace().

It's likely due to the precompiled nature of closures, vs the compilation
happening multiple times at invocation in the preg_replace /e case.

But it's still worth noting that switching from the /e style to a more
traditional preg_replace_callback implementation will get you a significant
boost in performance of that.

Now, keep in mind, we're talking 0.000005 seconds saved per "execution"
(group of 6 replacements). So it's not likely to matter much or be worth
worrying about...

My $0.02 at least...

Anthony

--047d7b675b2684c93a04dbe4b384--