[php] spatie invoegen in string

[Haranaka]

Ik heb een waarde x die 36 chars bevat, maar voor verdere verwerking moet deze lange string onderbroken worden in 4 stukken van ieder 8 chars. Ik zoeken op php.net en kwam op de functie wordwrap, maar die doet niet wat ik wil

PHP:

$x="00001ad3b32fdd596d31283800000000";
$newx=wordwrap($x, 8," ");
echo "$newx\n";

Hieruit verwacht ik dat hij zegt:

00001ad3 b32fdd59 6d312838 00000000

Dat hij dus om de 8 chars een spatie invoegt. Maar je verwacht het al, het werkt niet zoals ik wil, anders zou ik het hier niet posten. Hij spuigt gewoon de oude waarde uit, dus zonder spaties.

Iemand die me uit de brand kan helpen?

[Sybr_E-N]

Kun je niet iets maken met de functie str_split? Je zit dan wel met array's opgescheep, of met een normaal while of for lusje kun je jouw string ook wel in stukken splitsen.

[Haranaka]

Mijn eerste gedacht was ook str_split, maar die is : (PHP 5 CVS only)

ik wil graag een while lus voorkomen omdat ik het in een script moet verwerken dat het zo'n 10.000 keer moet doen.

[corani]

Is die string altijd 32 tekens?

PHP:

$x = substr($x, 0, 8)." ".substr($x, 8, 8)." ".substr($x, 16, 8)." ".substr($x, 24, 8);

zoiets?

[ACM]

En dan hebben ze zo'n duidelijke manual

quote: http://nl2.php.net/wordwrap

string wordwrap ( string str [, int width [, string break [, boolean cut]]])

Returns a string with str wrapped at the column number specified by the optional width parameter. The line is broken using the (optional) break parameter.

wordwrap() will automatically wrap at column 75 and break using '\n' (newline) if width or break are not given.

If the cut is set to 1, the string is always wrapped at the specified width. So if you have a word that is larger than the given width, it is broken apart. (See second example).

[Verwijderd]

Waarom gebruik je

PHP:

substr() ;

niet?

[Sybr_E-N]

Ow, maar substr() werkt ook wel.

Krijg je het volgende:

PHP:

$x= '00001ad3b32fdd596d31283800000000';

$sub1 = substr($x, 0, 8);
$sub2 = substr($x, 8, 8);
$sub3 = substr($x, 16, 8);
$sub4 = substr($x, 24, 8);

[Haranaka]

Doh , thanks ACM. Ook de anderen btw

[Grijze Vos]

maak er wel even iets moois van mensen, dat op alle lengtes werkt...

PHP:

while ($i < strlen($string))
{
  $string2 = substr($string,$i,8) . " ";
  $i+=8;
}

[ Voor 10% gewijzigd door Grijze Vos op 06-11-2003 20:09 ]

[djluc]

Grijze Vos schreef op 06 november 2003 @ 20:08:
maak er wel even iets moois van mensen, dat op alle lengtes werkt...

PHP:

while ($i < strlen($string))
{
  $string2 = substr($string,$i,8) . " ";
  $i+=8;
}

zie ook:

ik wil graag een while lus voorkomen omdat ik het in een script moet verwerken dat het zo'n 10.000 keer moet doen.

Als het een eenmalige oplossing is dan is het wel oke zoals de TS het nu doet. Maar als je een beetje een universeel systeempje wilt maken is de oplossing van grijze vos beter.

[stekkel]

De allersnelste oplossing:

PHP:

$splitted_string = chunk_split ( $string , 8 , ' ');

[ Voor 49% gewijzigd door stekkel op 06-11-2003 20:35 ]

[CrashOne]

Heb net een mooie (naar mijn idee) functie geschreven, wel asp:

VBScript:

Function cutWord(text)

    dim mess
    set mess = new regexp

    mess.pattern = "(\S{25}?)(\S{25}?)"

    text = mess.replace(text, "$1-<br>$2")

    cutWord = text

End Function

Kan natuurlijk altijd dynamischer door je lengte ook in de functie mee te geven.

[ Voor 11% gewijzigd door CrashOne op 06-11-2003 22:38 . Reden: edit de edit de edit ]

[Burat]

Een regexp is zwaar overkill. De substr is denk ik het snelst omdat die direct naar een c functie wordt gemapt. Vooral als het 10.000 keer uitgevoerd moet worden.

Voor performance checken is het misschien aardig om even te profilen wat het snelst gaat. Leuk tooltje hiervoor is apd (http://pecl.php.net/package/apd)

[stekkel]

Burat schreef op 07 november 2003 @ 08:09:
Een regexp is zwaar overkill. De substr is denk ik het snelst omdat die direct naar een c functie wordt gemapt. Vooral als het 10.000 keer uitgevoerd moet worden.

substr vereist in dit geval 4 substr functie aanroepen en het vereist dat er concatinatie plaats moet middels implode.

chunk_split is 1 functie aanroep en concatinatie is niet nodig.

Wat zal sneller zijn?

[Burat]

Het is niet vanzelfsprekend dat die ene aanroep sneller is: sommige functies worden 1 op 1 gemapt naar een c-functie, zonder dat de php/zend engine er iets mee hoeft te doen waardoor het sneller is dan een korte 'simpele' functie.

In dit geval heb je gelijk, jouw oplossing is sneller.

test1.php

PHP:

<?php

apd_set_pprof_trace();
$string = "00001ad3b32fdd596d31283800000000";

for($i=0; $i < 10000; $i++)
{       $splitted_string = chunk_split ($string, 8, ' ');
}

echo $splitted_string;

?>

test2.php

PHP:

<?php

apd_set_pprof_trace();
$string = "00001ad3b32fdd596d31283800000000";

for($i=0; $i < 10000; $i++)
{       $splitted_string = substr($string, 0, 8).' '.substr($string, 8, 8).' '.substr($string, 16, 8).' '.substr($string, 24, 8);
}

echo $splitted_string;

?>

En de snelheid:

code:

root@devbak1:/data/www/apd_dump# pprofp -u pprof.06866

Trace for /home/bslagter/test/test1.php
Total Elapsed Time =    0.24
Total System Time  =    0.00
Total User Time    =    0.24


         Real         User        System             secs/    cumm
%Time (excl/cumm)  (excl/cumm)  (excl/cumm) Calls    call    s/call  Memory Usage Name
--------------------------------------------------------------------------------------
100.0  0.24  0.24   0.24  0.24   0.00  0.00  10000   0.0000    0.0000            0 chunk_split
  0.0  0.00  0.00   0.00  0.00   0.00  0.00     1   0.0000    0.0000            0 main
root@devbak1:/data/www/apd_dump# pprofp -u pprof.06867

Trace for /home/bslagter/test/test2.php
Total Elapsed Time =    0.78
Total System Time  =    0.00
Total User Time    =    0.78


         Real         User        System             secs/    cumm
%Time (excl/cumm)  (excl/cumm)  (excl/cumm) Calls    call    s/call  Memory Usage Name
--------------------------------------------------------------------------------------
100.0  0.78  0.78   0.78  0.78   0.00  0.00  40000   0.0000    0.0000            0 substr
  0.0  0.00  0.00   0.00  0.00   0.00  0.00     1   0.0000    0.0000            0 main

[Spider.007]

offtopic:
w00t die " APD extension"s zien er heel erg goed uit Burat

[stekkel]

Burat schreef op 09 november 2003 @ 22:55:
Het is niet vanzelfsprekend dat die ene aanroep sneller is: sommige functies worden 1 op 1 gemapt naar een c-functie, zonder dat de php/zend engine er iets mee hoeft te doen waardoor het sneller is dan een korte 'simpele' functie.

In dit geval heb je gelijk, jouw oplossing is sneller.

Burat

Ben er mee eens dat het niet vanzelf sprekend is maar door voldoende ervaring weet ik inmiddels wel welke functies binnen php tijd kosten en welke snel zijn. (ik heb te veel php performance tuning docs gelezen)

Bedankt dat je het getest hebt !!!

Volgende keer zal ik het zelf testen, nadat ik dat apd geinstalleerd heb. Heb al veel van die apd uitdraaien gezien maar ben altijd te lui geweest om het op mijn eigen server te installeren

[Verwijderd]

Burat: Een regexp is zwaar overkill.

Hrmph.

PHP:

function timer() {
    static $prev, $last = 0;
    $prev = $last;
    $last = array_sum(explode(" ", microtime()));
    return $last - $prev;
}

$string = "00001ad3b32fdd596d31283800000000";
$iters  = 500000;

echo "Doing $iters iterations...\n";
timer();
for ($i = 0; $i < $iters; $i++) {
    $splitted_string = substr($string, 0,  8) . ' '
                     . substr($string, 8,  8) . ' '
                     . substr($string, 16, 8) . ' '
                     . substr($string, 24, 8);
}
echo "4 times substr:     ", timer(), " seconds\n";
// echo "Result: $splitted_string\n";

timer();
for ($i = 0; $i < $iters; $i++) {
    $splitted_string = preg_replace('/(.{8})/', '$1 ', $string);
}
echo "preg_replace (NL):  ", timer(), " seconds\n";
// echo "Result: $splitted_string\n";

timer();
for ($i = 0; $i < $iters; $i++) {
    $splitted_string = preg_replace('/(.{8})/', '$1 ', $string, 3);
}
echo "preg_replace (L=3): ", timer(), " seconds\n";
// echo "Result: $splitted_string\n";

code:

Doing 500000 iterations...
4 times substr:     6.3783819675446 seconds
preg_replace (NL):  5.8873070478439 seconds
preg_replace (L=3): 5.5973950624466 seconds

YMMV.

[Burat]

Verwijderd schreef op 10 november 2003 @ 10:01:
Hrmph.

Het is sneller dan substr() ja. Maar vergelijk het eens met chunk_split. Dan is het ineens bijna 40% trager!

En in dit geval is de regexp nog redelijk snel. Zie onderaan de post trouwens voor een APD Trace.

De regel voor een regexp is over het algemeen:
-> Als je moet kiezen tussen een regexp en een zelf geschreven PHP Functie is een regexp sneller
-> Als je kan kiezen tussen een regexp en een andere PHP Functie die hetzelfde kan, is de andere PHP Functie sneller.

De preg_replace is intern namelijk wel een mooie C-functie in Zend (en geen extension):

PHP:

<?php

$string = "00001ad3b32fdd596d31283800000000";

$splitted_string = preg_replace("/(.{8})/", "\\1 ", $string);

echo $splitted_string;

?>

code:

Bert Slagter@bert-laptop /usr/src/php-4.3.4
$ ./sapi/cli/php ./test.php
Class stdClass: [no user functions]
Class __PHP_Incomplete_Class: [no user functions]
Class Directory: [no user functions]
filename:       /usr/src/php-4.3.4/test.php
function name:  (null)
number of ops:  12
line     #  op                   fetch  ext  operands
-------------------------------------------------------------------------------
   3     0  FETCH_W                          $0, 'string'
         1  ASSIGN                           $0, '00001ad3b32fdd596d31283800000000'
   5     2  SEND_VAL                         '%2F%28.%7B8%7D%29%2F'
         3  SEND_VAL                         '%5C1+'
         4  FETCH_R                          $3, 'string'
         5  SEND_VAR                         $3
         6  DO_FCALL                      3  $4, 'preg_replace', 0
         7  FETCH_W                          $2, 'splitted_string'
         8  ASSIGN                           $2, $4
   7     9  FETCH_R                          $6, 'splitted_string'
        10  ECHO                             $6
  10    11  RETURN                           1

00001ad3 b32fdd59 6d312838 00000000

Dit is trouwens gemaakt met de "Vulcan Logic Disassambler" van Derrick Rethans (Een nederlandse PHP devver).

test3.php

PHP:

<?php

apd_set_pprof_trace();
$string = "00001ad3b32fdd596d31283800000000";

for($i=0; $i < 10000; $i++)
{       $splitted_string = preg_replace("/(.{8})/", "\\1 ", $string);
}

echo $splitted_string;

?>

code:

Trace for /home/bslagter/test/test3.php
Total Elapsed Time =    0.35
Total System Time  =    0.01
Total User Time    =    0.34


         Real         User        System             secs/    cumm
%Time (excl/cumm)  (excl/cumm)  (excl/cumm) Calls    call    s/call  Memory Usage Name
--------------------------------------------------------------------------------------
100.0  0.35  0.35   0.34  0.34   0.01  0.01  10000   0.0000    0.0000            0 preg_replace
  0.0  0.00  0.00   0.00  0.00   0.00  0.00     1   0.0000    0.0000            0 main

[ Voor 3% gewijzigd door Burat op 10-11-2003 11:33 ]

[Verwijderd]

Burat: Het is sneller dan substr() ja.

substr() zou veel, véél, sneller moeten zijn dan de regex in dit soort gevallen, maar ik weet uit ervaring dat dat niet zo is. (Bijvoorbeeld in Perl is de substr oplossing zo'n vier keer zo snel als een regex, zoals je zou verwachten.)

Maar vergelijk het eens met chunk_split. Dan is het ineens bijna 40% trager!

De kwaliteit van de string functies in PHP is heel wisselend, en dan vertrouw ik liever op de PCRE dan te moeten onthouden dat in dit specifieke geval chunk_split een stuk sneller is (net als word_wrap?), maar substr weer langzamer. Er zijn meer dan 80 string functies...

De preg_replace is intern namelijk wel een mooie C-functie in Zend (en geen extension).

Hm? Bij jou is ext/pcre leeg?

[stekkel]

Verwijderd schreef op 10 november 2003 @ 13:04:
[...]
substr() zou veel, véél, sneller moeten zijn dan de regex in dit soort gevallen, maar ik weet uit ervaring dat dat niet zo is. (Bijvoorbeeld in Perl is de substr oplossing zo'n vier keer zo snel als een regex, zoals je zou verwachten.)

Je vergeet een ding, een functie aanroep kost ook tijd. In geval van substr gaat het om 4 functie aanroepen. Daarnaast is concatinatie van strings in php traag. In geval van de substr oplossing gebeurd dat 3 x.

[.oisyn]

Het is natuurlijk niet de functieaanroep dat het zoveel trager maakt, dat is verwaarloosbaar. Waar het om gaat is dat er 4x een concat gedaan moet worden (wat dus sowieso al 4x een bufferallocatie betekent) zoals je al zei, maar ook dat voor elke keer dat substr wordt aangeroepen ook nog eens een buffer gealloceerd moet worden