Prevent 1 character from repeating

[mramonster]

I'm looking for a way to stop a "-" from repeating in a string such as:
$string="this---is-my--string";

to

$string="this-is-my-string";

but only for a -

[planetsim]

How is this string being made ? Could help isolate it without needing to do anything to the string. However this should do it.

$string = preg_replace( "/([-]+)/", "-", $string );

The main thing here is the + in the regular expression it looks for 1 or more.

[nrg_alpha]

planetsim;10897407 wrote:

$string = preg_replace( "/([-]+)/", "-", $string );

That would work.. however, be mindful that you are doing two things that are un-necessary in this case.

a) you are creating a capture by using the brackets (which we don't need), and
b) while there may not be any true benefit to this, there is no true need for a character class... (in a timed test, the results flip-flopped back and forth in favor between character class vs non character class.. so admittedly, this is probably a more pointless point, but in any case...

$string = preg_replace('#-+#' ,'-', $string);

[NogDog]

You could add this to your test, to see if not having to replace single hyphens makes a difference:

$string = preg_replace('#-{2,}#' ,'-', $string);

🙂

[nrg_alpha]

NogDog;10897426 wrote:

You could add this to your test, to see if not having to replace single hyphens makes a difference:

$string = preg_replace('#-{2,}#' ,'-', $string);

🙂

Nice one Nog! In a timed test, you solution was even faster.. huh.. I wonder aloud if it's due to lazy quantifiers or that your solution ignores single dashed characters within the target string. In either case, good show!

[Weedpacket]

I wonder how "#--+#" will perform? Probably compiles to the same NFA as NogDog's; if it does it would be the same.

[nrg_alpha]

Weedpacket;10897475 wrote:

I wonder how "#--+#" will perform? Probably compiles to the same NFA as NogDog's; if it does it would be the same.

EDIT - Unless I am missing something here, isn't PCRE strictly NFA based regardless?

Well, for anyone interested, here is the test code (nothing spectacular, but does its job I suppose):

time.php

$comparison = array('#-{2,}#', '#--+#');
$str = 'this---is-my--string';
$loop = 1000;

echo '&bull; target string: (" ' . $str . ' ")<br />' . '&bull; num. of iterations: ' . $loop . '<br /><br />';

foreach($comparison as $val){
   $time_start = microtime(true);
   for($i = 0; $i < $loop; $i++){
      $matches = preg_replace($val ,'-', $str);
   }
   $time_end = microtime(true);
   $elapsed_time = round($time_end-$time_start, 4);
   echo "Pattern: " . htmlentities($val) . "<br />time: $elapsed_time seconds<br />";
   echo 'Output:<br />' . '<pre>' . print_r($matches, true) . '<br /><hr noshade="false" size="1" />';
}

I used to just pitch in preg pattern suggestions without actually testing beforehand how efficient [or in-efficient] they are (and still do at times).. but figured I would just pull up time.php everytime I need to test some patterns to see the end results.

And as for Weed's suggestion, the results seem to sway back and forth.. so close enough either way.

[Weedpacket]

It varies even more wildly as a function of the length of the string/number of repeats; sometimes one would be faster in a particular instance, other times another. So in that sense any one - including replacing "#-(?=-)#" with an empty string, but not "#(?<=-)-#" - is as good as any other.

[Installer]

Just another suggestion: try this test:

$str = 'this---is-my--string';
$loop = 1000; 

for ($l = 0; $l <= 2; $l++) {
    $str = str_repeat($str, pow(10, $l)); 
    echo '-------------<br />';
    echo 'String length: ' . strlen($str) . '<br />';

$start = microtime(true);
for ($i = 0; $i < $loop; $i++) {
    $string = $str;
    while (strpos($string, '--') !== false) {
        $string = str_replace('--', '-', $string);
    }
}
echo microtime(true) - $start . ': ';
echo '<i>str_replace(\'--\', \'-\', $string)</i>' . '<br />';

$start = microtime(true); 
for($i = 0; $i < $loop; $i++) { 
    $string = $str;
    $string = preg_replace('#-{2,}#', '-', $string); 
} 
echo microtime(true) - $start . ': ';
echo '<i>preg_replace(\'#-{2,}#\', \'-\', $string)</i>' . '<br />';

$start = microtime(true); 
for($i = 0; $i < $loop; $i++) { 
    $string = $str;
    $string = preg_replace('#--+#', '-', $string); 
} 
echo microtime(true) - $start . ': ';
echo '<i>preg_replace(\'#--+#\', \'-\', $string)</i>' . '<br />';
}

[nrg_alpha]

What I find interesting with the results from Installer's code is that (for this particular situation), when the string length was 20, Nog's solution more or less was the fastest of the three (occasionally my solution pulled ahead). But the str_replace solution never came out on top. But for the other two iterations (string lengths of 200 and 20000), str_replace pulls ahead.

Now I know that in general, functions like str_replace is faster than regex, but those results are rather suprising, in that I figured the str_replace would beat them all at every level.

[Weedpacket]

But it's not just str_replace(); it's while(strpos()!==false){str_replace()}.
The strpos() could be avoided:

do
{
   $old_string = $string;
   $string = str_replace();
} while($oldstring!=$string);

But really, this is starting to get silly 🙂

[nrg_alpha]

Weedpacket;10897628 wrote:

But really, this is starting to get silly 🙂

In other words, we're splitting hairs now? 😉
In all seriousness, agreed. For small tasks, the performance differences once past a certain optimization point will most likely be imperceptable to web visitors.

[Installer]

I was going to say something about encouraging inexperienced coders to try string functions that are easier to read and maintain for less complicated tasks, especially when the time and resource cost is equivalent or even way better, and I wanted to ask how much more efficient is testing two strings for inequality than using strpos(). But I guess I don't want to expose any more of my own silliness than I already have, so I'll just back out of this thread.

[NogDog]

Installer;10897641 wrote:

I was going to say something about encouraging inexperienced coders to try string functions that are easier to read and maintain for less complicated tasks, especially when the time and resource cost is equivalent or even way better, and I wanted to ask how much more efficient is testing two strings for inequality than using strpos(). But I guess I don't want to expose any more of my own silliness than I already have, so I'll just back out of this thread.

A little silliness would be welcome with all the serious crap going on in the world these days. But seriously [uh, need a better adverb there] it's all good if it makes us think and compare the options. This sort of discussion is good for both n00bs and vets in stretching our brains a bit and really thinking about what we're doing.

[Weedpacket]

Well, I just figured that if we kept on I'd've broken out a couple more - one using preg_split() and one using explode() and both using join().

[NogDog]

How about strtok()? 😉

<?php

$input = "foo---bar-and----so--forth";
$output = "";
$tok = strtok($input, '-');
while($tok !== false)
{
   $output .= $tok . '-';
   $tok = strtok('-');
}
$output = rtrim($output, '-');
echo $output;