Tutorial 5: Array to xml

Door xleeuwx op maandag 23 juni 2014 23:50 - Reacties (28)
Categorie: PHP Scripts, Views: 6.285

Voorwoordje

Het probleem:
De afgelopen tijd heb ik een hoop webservices moeten maken, een van de dingen wat ik tegen kwam was het vertalen van een array naar xml.
De oplossing:
Er zijn genoeg oplossingen hiervoor te bedenken en de een is beter als de ander, ik heb er voor gekozen om hiervoor een functie te maken die een simpele array omzet in een xmlbestand.
Alternatieven
Hoor ik graag, laat maar in een reactie achter hoe jij denkt dat dit beter opgelost kan worden.

De tutorial

Als eerste hebben we data nodig voor de array, zonder array geen data.

We gaan even zoeken in de openkvk database en halen de JSON op van ING, omdat de data van buiten komt en we niet weten of deze ook altijd beschikbaar is heb ik hem in een try en catch gezet.

PHP:
1
2
3
4
5
6
7
8
9
<?php
    $data = array();
    try {
        $data = file_get_contents('http://officieel.openkvk.nl/json/ing');
        $data = json_decode($data, true);
    } catch(Exception $e) {
        throw new Exception('Error loading $data :', 0, $e);
    }
?>



Om te kijken wat er in deze array zit gooien we even een vardump met pre's er uit

PHP:
1
2
3
4
5
<?php
    echo '<pre>';
        var_dump($data);
    echo '</pre>';
?>



Verder bestaat de file uit 2 functies, één functie om de settings te bepalen en één functie om de XML aan te maken

Settings:

PHP:
1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
    function arrayToXML(array $data, $rootElement = '<root></root>', $encoding = 'utf-8', $version = '1.0') {
    
        ## -- Create headers
            $xml = '<?xml version="'.$version.'" encoding="'.$encoding.'" ?>'.$rootElement;
        
        ## -- Create the XML
            $xml = createXML($data, new SimpleXMLElement($xml))->asXML();
        
        ## -- Return XML
            return $xml;
    }
?>



createXML:

PHP:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?php
    function createXML(array $arr, SimpleXMLElement $xml) {
        
        foreach ($arr as $k => $v) {
            ## -- Check if Key is numeric
                $k = (is_numeric($k) ? "num_".$k : $k);
                
                ## -- Check if there is a space in the tag
                    if(preg_match('/\s/', $k)) {
                        throw new Exception('Illegal space in tag name. tag: '.$k);
                    }
                
                ## -- Check illegal characters
                    if(!(preg_match('/^[a-z_]+[a-z0-9\:\-\.\_]*[^:]*$/i', $k, $matches) && $matches[0] == $k)) {
                        throw new Exception('Illegal character in tag name. tag: '.$k);
                    }                       
            
            ## -- Set child
                is_array($v) ? createXML($v, $xml->addChild($k)) : $xml->addChild($k, $v);
        }
        
        return $xml;
    }
?>



En uiteindelijk hebben we natuurlijk een echo nodig van de xml

PHP:
1
echo arrayToXML($data);




Alles bij elkaar krijgen we dan het eindresultaat van:

PHP:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
<?php
    function arrayToXML(array $data, $rootElement = '<root></root>', $encoding = 'utf-8', $version = '1.0') {   
        ## -- Create headers
            $xml = '<?xml version="'.$version.'" encoding="'.$encoding.'" ?>'.$rootElement;
        
        ## -- Create the XML
            $xml = createXML($data, new SimpleXMLElement($xml))->asXML();
        
        ## -- Return XML
            return $xml;
    }
    
    function createXML(array $arr, SimpleXMLElement $xml) {     
        foreach ($arr as $k => $v) {
            ## -- Check if Key is numeric
                $k = (is_numeric($k) ? "num_".$k : $k);
                
                ## -- Check if there is a space in the tag
                    if(preg_match('/\s/', $k)) {
                        throw new Exception('Illegal space in tag name. tag: '.$k);
                    }
                
                ## -- Check illegal characters
                    if(!(preg_match('/^[a-z_]+[a-z0-9\:\-\.\_]*[^:]*$/i', $k, $matches) && $matches[0] == $k)) {
                        throw new Exception('Illegal character in tag name. tag: '.$k);
                    }                       
            
            ## -- Set child
                is_array($v) ? createXML($v, $xml->addChild($k)) : $xml->addChild($k, $v);
        }
        ## -- Return XML
            return $xml;        
    }
    
    $data = array();
    
    try {
        $data = file_get_contents('http://officieel.openkvk.nl/json/ing');
        $data = json_decode($data, true);
    } catch(Exception $e) {
        throw new Exception('Error loading $data :', 0, $e);
    }

    echo arrayToXML($data);
?>

Het eindresultaat
ik heb even wat er uit geknipt voor de leesbaarheid.

XML:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
<?xml version="1.0" encoding="UTF-8"?>
<root>
   <num_0>
      <rechtspersoon>ING Bank N.V.</rechtspersoon>
      <vestigingsnummer>000019531656</vestigingsnummer>
      <adres>Bijlmerplein 888</adres>
      <woonplaats>Amsterdam</woonplaats>
      <kvk>330314310000</kvk>
      <handelsnamen>
         <bestaand>
            <num_0>ING Bank N.V.</num_0>
            <num_1>ING Bank</num_1>
            <num_2>Internationale Nederlanden Bank</num_2>
            <num_3>ING Financial Markets</num_3>
            <num_4>ING Securities Services</num_4>
            <num_5>Way2Pay</num_5>
            <num_6>ING</num_6>
            <num_7>ING InsideBusiness</num_7>
            <num_8>ING Card</num_8>
            <num_9>ING PKI Service Centre</num_9>
            <num_10>ING Corporate PKI</num_10>
            <num_11>ING Real Estate Finance</num_11>
            <num_12>ING Direct</num_12>
         </bestaand>
      </handelsnamen>
      <postcode>1102MG</postcode>
      <type>Hoofdvestiging</type>
      <kvks>33031431</kvks>
   </num_0>
   <num_1>
      <rechtspersoon>ING Lease (Ireland) B.V.</rechtspersoon>
      <vestigingsnummer>000016031970</vestigingsnummer>
      <adres>Bijlmerplein 888 AMP H 01.036</adres>
      <woonplaats>Amsterdam Zuidoost</woonplaats>
      <kvk>332261610000</kvk>
      <handelsnamen>
         <bestaand>
            <num_0>ING Lease (Ireland) B.V.</num_0>
            <num_1>ING Bank</num_1>
         </bestaand>
      </handelsnamen>
      <postcode>1102MG</postcode>
      <type>Hoofdvestiging</type>
      <kvks>33226161</kvks>
   </num_1>
   <num_2>
      <rechtspersoon>ING Bank N.V.</rechtspersoon>
      <vestigingsnummer>000016593421</vestigingsnummer>
      <adres>Schimmelt 34</adres>
      <woonplaats>Eindhoven</woonplaats>
      <kvk>330314310647</kvk>
      <handelsnamen>
         <bestaand>
            <num_0>ING Bank N.V.</num_0>
            <num_1>ING Real Estate Finance</num_1>
         </bestaand>
      </handelsnamen>
      <postcode>5611ZX</postcode>
      <type>Nevenvestiging</type>
      <kvks>33031431</kvks>
   </num_2>
   <num_3>
      <rechtspersoon>ING Bank N.V.</rechtspersoon>
      <vestigingsnummer>000016593103</vestigingsnummer>
      <adres>De entree 201</adres>
      <woonplaats>Amsterdam</woonplaats>
      <kvk>330314310645</kvk>
      <handelsnamen>
         <bestaand>
            <num_0>ING Bank N.V.</num_0>
            <num_1>ING Real Estate Finance</num_1>
         </bestaand>
      </handelsnamen>
      <postcode>1101HG</postcode>
      <type>Nevenvestiging</type>
      <kvks>33031431</kvks>
   </num_3>  
   <num_9>
      <rechtspersoon>ING Bank</rechtspersoon>
      <vestigingsnummer>000019538480</vestigingsnummer>
      <adres>Noordeinde 159</adres>
      <woonplaats>Almere</woonplaats>
      <kvk>330314310560</kvk>
      <handelsnamen>
         <bestaand>
            <num_0>ING Bank</num_0>
         </bestaand>
      </handelsnamen>
      <postcode>1334AN</postcode>
      <type>Nevenvestiging</type>
      <kvks>33031431</kvks>
   </num_9>
</root>

Volgende: TransIP: Stack 11-'15 TransIP: Stack
Volgende: Tutorial 4: LocalStorage 06-'14 Tutorial 4: LocalStorage

Reacties


Door Tweakers user sfranken, dinsdag 24 juni 2014 00:07

1) Nooit variabelen rechstreeks in een string kwakken, daar heb je concatinatie voor.
2) Waarom een eigen script schrijven voor iets wat standaard in PHP zit? Zie http://php.net/manual/en/book.simplexml.php

Door Tweakers user PoweRoy, dinsdag 24 juni 2014 08:09

sfranken schreef op dinsdag 24 juni 2014 @ 00:07:
1) Nooit variabelen rechstreeks in een string kwakken, daar heb je concatinatie voor.
2) Waarom een eigen script schrijven voor iets wat standaard in PHP zit? Zie http://php.net/manual/en/book.simplexml.php
Couldn't agree more! En zelf XML implementeren is zonde van je tijd en een veel grotere kans dat je fouten maakt.

Gebruik dus libraries die aanwezig zijn:
$newsXML = new SimpleXMLElement("<news></news>");
$newsXML->addAttribute('newsPagePrefix', 'value goes here');
$newsIntro = $newsXML->addChild('content');
$newsIntro->addAttribute('type', 'latest');
Header('Content-type: text/xml');
echo $newsXML->asXML();

Krijg je dit:
<?xml version="1.0"?>
<news newsPagePrefix="value goes here">
<content type="latest"/>
</news>

Liever zou ik helemaal XML vermijden. In webdevelopment is mijn eerste keus vaak JSON tenzij ik iets anders moet gebruiken ;) Veel makkelijker in gebruik, minder overhead en leesbaar!

Door Tweakers user xleeuwx, dinsdag 24 juni 2014 09:21

sfranken schreef op dinsdag 24 juni 2014 @ 00:07:
1) Nooit variabelen rechstreeks in een string kwakken, daar heb je concatinatie voor.
2) Waarom een eigen script schrijven voor iets wat standaard in PHP zit? Zie http://php.net/manual/en/book.simplexml.php
1. Er zit totaal geen verschil in, daarnaast doe ik bijna nooit zo maar hier was het voor de leesbaarheid iets beter om het op deze manier te doen.

2. Deze functie is toch anders tenzij je me kan laten zien hoe je een array direct gebruikt in de simplexml class. Je zou eventueel nog in mijn functie inplaats van zelf de xml te schrijven het door de simple xml class kunnen laten doen alleen heb je dan meer overhead.
PoweRoy schreef op dinsdag 24 juni 2014 @ 08:09:
[...]
Gebruik dus libraries die aanwezig zijn:

PHP:
1
2
3
4
5
6
$newsXML = new SimpleXMLElement("<news></news>");
$newsXML->addAttribute('newsPagePrefix', 'value goes here');
$newsIntro = $newsXML->addChild('content');
$newsIntro->addAttribute('type', 'latest');
Header('Content-type: text/xml');
echo $newsXML->asXML();


Krijg je dit:

XML:
1
2
3
4
<?xml version="1.0"?>
<news newsPagePrefix="value goes here">
    <content type="latest"/>
</news>


Liever zou ik helemaal XML vermijden. In webdevelopment is mijn eerste keus vaak JSON tenzij ik iets anders moet gebruiken ;) Veel makkelijker in gebruik, minder overhead en leesbaar!
Over het algemeen gebruik ik ook liever JSON, maar bij webservices gebruiken wij standaard XML.

[Reactie gewijzigd op dinsdag 24 juni 2014 09:22]


Door Tweakers user -RetroX-, dinsdag 24 juni 2014 09:25

Er zijn natuurlijk zat functies die een XML kunnen bouwen maar ik vind het een goed idee dat mensen dit soort tutorials maken. Het zonder nadenken implementeren van bepaalde functionaliteit zonder het te begrijpen is een enorm risico. Beginners kunnen hiermee juist een beeld krijgen wat zulke functies nu eigenlijk doen.

En voor tweakers die het allemaal al wel weten: het houdt je scherp om zo'n functie aandachtig te bekijken en zelf te bedenken wat je anders zou doen.

Ik kan deze tuts in elk geval zeker waarderen :)

Van mijn kant dan een inhoudelijke reactie: is het niet mooier om van die variabelen voor enter/tab een constante te maken als XML_EOL en XML_TAB ofzo?

Door Tweakers user RobIII, dinsdag 24 juni 2014 09:27

Never, ever, *EVER*, EVER je eigen XML in mekaar gaan lopen fröbelen. Je code gaat faliekant mis op 't moment dat je, bijvoorbeeld, een key hebt waar "foo bar" in staat (wat een <foo bar> element geeft...) en dan hebben we 't nog niet eens gehad over entities die je dient te escapen zoals " en & (wat dus &quot; en &amp; moet worden). En waag 't niet er dan maar gewoon 'htmlentities' overheen te raggen :X

Gebruik altijd een (bewezen) library of functies die in je platform/taal aanwezig zijn en daarvoor dienen; zoals hierboven aangegeven is SimpleXML bijv. een mogelijkheid. Op 't moment dat je strings aan mekaar gaat lopen plakken en je met XML bezig bent -> instant fail.

Het ergste is nog: uiteindelijk is 't vaak "de andere kant" die met deze "XML" moet werken die hier de dupe van wordt die dan, op zijn/haar beurt, weer een vage workaround moet maken en dus op zijn/haar manier weer met strings gaat lopen kutten en "handmatig parsen" van de "XML" om 't maar werkbaar te krijgen. En voila, je hebt een hele reeks domino's in gang gezet in een Rube Goldberg contraptie.
-RetroX- schreef op dinsdag 24 juni 2014 @ 09:25:
Er zijn natuurlijk zat functies die een XML kunnen bouwen maar ik vind het een goed idee dat mensen dit soort tutorials maken. Het zonder nadenken implementeren van bepaalde functionaliteit zonder het te begrijpen is een enorm risico. Beginners kunnen hiermee juist een beeld krijgen wat zulke functies nu eigenlijk doen.
Het gevaar is dat de ene blinde de andere blinde leidt. Die libraries en functies zijn er met een reden. En juist beginners nemen dit soort zaken klakkeloos over omdat 't lekker makkelijk en simpel uitziet maar ondertussen klopt er geen hout van en gaan ze over een paar weken op hun bek zonder te weten waar 't vandaan komt.

Nee; als ik één advies mag geven aan beginners: blijf hier verre van a.u.b. De intentie van xleewx is zéker goed, maar "in te long run" doen dergelijke blogposts (ondanks de "disclaimers" a-la "Daarnaast zou je eventueel de waardes van $value kunnen strippen, encode ...Maar hier dient zeker rekening mee te worden gehouden.") meer kwaad dan goed.

[Reactie gewijzigd op dinsdag 24 juni 2014 09:45]


Door Tweakers user -RetroX-, dinsdag 24 juni 2014 09:51

RobIII schreef op dinsdag 24 juni 2014 @ 09:27:
Het gevaar is dat de ene blinde de andere blinde leidt. Die libraries en functies zijn er met een reden. En juist beginners nemen dit soort zaken klakkeloos over omdat 't lekker makkelijk en simpel uitziet maar ondertussen klopt er geen hout van en gaan ze over een paar weken op hun bek zonder te weten waar 't vandaan komt.
Ik ben het principieel volledig met je eens. Echter, beginners moeten toch basisprincipes leren. Het is een tutorial van een principe en geen kant-en-klare library.

Natuurlijk schuilt er een enorm gevaar in het feit dat bepaalde beginners code zo overnemen. Maar dat is met libraries niet anders. Ik kom in het wild zoveel meuk tegen van "bewezen" libararies waarin zo ontzettend veel fout gaat omdat ze de principes niet snappen.

Door Tweakers user RobIII, dinsdag 24 juni 2014 10:03

-RetroX- schreef op dinsdag 24 juni 2014 @ 09:51:
[...]
Echter, beginners moeten toch basisprincipes leren.
Dan kun je ze beter metéén goed aanleren; als de aapjes namelijk een trucje eenmaal kennen is 't verdomd lastig 't er weer uit te slaan / corrigeren. Daar helpen geen disclaimers of "het is stiekem niet (helemaal) goed maar voor nu/dit 'simpele voorbeeld' werkt het..." aan.

Juist beginners hebben er baat bij iets meteen goed (aan) te leren i.p.v. eerst de halfslachtige foute manier; dat maakt 't leerproces ook niet heel veel duidelijker als je eerst iets leert en een paar weken later blijkt dat 't eigenlijk totaal nutteloos was. Lekker verwarrend. Als je strings aan elkaar wil leren plakken; prima, maar doe dat dan met een "lorem ipsum" ofzo en niet met XML.
-RetroX- schreef op dinsdag 24 juni 2014 @ 09:51:
Ik kom in het wild zoveel meuk tegen van "bewezen" libararies waarin zo ontzettend veel fout gaat omdat ze de principes niet snappen.
Je zegt het zelf al: "omdat ze de principes niet snappen". Nou dan! Leer ze dan de principes i.p.v. wat voorgekauwde (incorrecte) code op te lepelen en af te doen als "voor dit voorbeeld werkt het".

In de Devschuur® hanteren we niet voor niets 't credo:
Give a man a fish and feed him for a day. Teach a man how to fish and feed him for a lifetime.

Het web staat al vol genoeg met foute/verkeerde informatie; maak 't dan niet erger.

[Reactie gewijzigd op dinsdag 24 juni 2014 10:08]


Door Tweakers user -RetroX-, dinsdag 24 juni 2014 10:20

True.

Het credo van vissen ondersteun ik van harte. Maar er wordt vaak vergeten dat de visser ook een hengel moet leren maken. En die eerste hengel is toch vaak een houten stok met een draadje.

Wellicht iets voor een tutorial 6?

Door Tweakers user xleeuwx, dinsdag 24 juni 2014 10:21

RobIII schreef op dinsdag 24 juni 2014 @ 10:03:
[...]

Dan kun je ze beter metéén goed aanleren; als de aapjes namelijk een trucje eenmaal kennen is 't verdomd lastig 't er weer uit te slaan / corrigeren. Daar helpen geen disclaimers of "het is stiekem niet (helemaal) goed maar voor nu/dit 'simpele voorbeeld' werkt het..." aan.

Juist beginners hebben er baat bij iets meteen goed (aan) te leren i.p.v. eerst de halfslachtige foute manier; dat maakt 't leerproces ook niet heel veel duidelijker als je eerst iets leert en een paar weken later blijkt dat 't eigenlijk totaal nutteloos was. Lekker verwarrend. Als je strings aan elkaar wil leren plakken; prima, maar doe dat dan met een "lorem ipsum" ofzo en niet met XML.


[...]


Je zegt het zelf al: "omdat ze de principes niet snappen". Nou dan! Leer ze dan de principes i.p.v. wat voorgekauwde (incorrecte) code op te lepelen en af te doen als "voor dit voorbeeld werkt het".

In de Devschuur® hanteren we niet voor niets 't credo:
Give a man a fish and feed him for a day. Teach a man how to fish and feed him for a lifetime.

Het web staat al vol genoeg met foute/verkeerde informatie; maak 't dan niet erger.
Zal strax even de validatie er in bakken, inderdaad is deze zo lek als een mandje.

Door Tweakers user RobIII, dinsdag 24 juni 2014 10:25

xleeuwx schreef op dinsdag 24 juni 2014 @ 10:21:
Zal strax even de validatie er in bakken, inderdaad is deze zo lek als een mandje.
Nee! NEE! Driewerf NEEN :X
Niks "validatie" er in bakken! :F Daar wordt 't écht, ECHT, niet beter op. :X Gebruik nou gewoon de bestaande functies/libraries en kap met 't aan elkaar fröbelen van strings die uiteindelijk, misschien, hopelijk, mogelijk resulteren in iets wat op 't eerste oog op XML lijkt.
-RetroX- schreef op dinsdag 24 juni 2014 @ 10:20:
Het credo van vissen ondersteun ik van harte. Maar er wordt vaak vergeten dat de visser ook een hengel moet leren maken. En die eerste hengel is toch vaak een houten stok met een draadje.
Niet dat ik zin heb om metaforen tot op 't bot te gaan lopen uitpluizen totdat er ergens iets blijkt niet helemaal op te gaan: juist een beginner koopt zijn hengel kant-en-klaar in de winkel (en laat zich adviseren door iemand die weet waar 'ie over praat) en gaat pas z'n eigen hengel maken/samenstellen als 'ie weet waar 'ie mee bezig is.

[Reactie gewijzigd op dinsdag 24 juni 2014 10:31]


Door Tweakers user -RetroX-, dinsdag 24 juni 2014 10:45

RobIII schreef op dinsdag 24 juni 2014 @ 10:25:
Niet dat ik zin heb om metaforen tot op 't bot te gaan lopen uitpluizen totdat er ergens iets blijkt niet helemaal op te gaan: juist een beginner koopt zijn hengel kant-en-klaar in de winkel (en laat zich adviseren door iemand die weet waar 'ie over praat) en gaat pas z'n eigen hengel maken/samenstellen als 'ie weet waar 'ie mee bezig is.
Eens. Maar innovatie ontstaat niet door enkel te kijken naar wat anderen reeds uitgevonden hebben. Zelf het wiel uitvinden kán heel gevaarlijk en tamelijk zinloos zijn. Maar als je het je kan permitteren dan kan het ook een goede leerschool zijn. De broertjes Wright konden ook geen bestelling plaatsen bij Boeing. Zit er een risico aan? Absoluut!

Door Tweakers user RobIII, dinsdag 24 juni 2014 10:51

De broertjes Wright konden ook geen bestelling plaatsen bij Boeing.
Zullen we kappen met metaforen?
xleewx kan namelijk wél; bestellen bij Boeing; dat voordeel heeft 'ie nou eenmaal wél i.t.t. de broertjes Wright.

Standing on the shoulder of giants

Als je een JSF gaat bouwen ga je ook weer eerst uitvogelen hoe een vleugel werkt? Of bouw je verder op ideeën / principes die inmiddels wel bewezen zijn?
Maar innovatie ontstaat niet door enkel te kijken naar wat anderen reeds uitgevonden hebben.
Nee, maar als jij gaat innoveren vind je ook altijd opnieuw de schroevendraaier uit? En de schuifmaat? En de decoupeerzaag? En de microscoop? En de microchip? Of neem je je (liefst flink volle) gereedschapskist en een zooi onderdelen als schroeven, planken, LCD displays, weerstanden en chips en bouw je met die bouwstenen je innovatie?

Zoals ik zei: Zullen we kappen met metaforen?

[Reactie gewijzigd op dinsdag 24 juni 2014 11:02]


Door Tweakers user -RetroX-, dinsdag 24 juni 2014 11:07

RobIII schreef op dinsdag 24 juni 2014 @ 10:51:
[...]
Nee, maar als jij gaat innoveren vind je ook altijd opnieuw de schroevendraaier uit?
Is dit niet tweakers? De plek waar we (soms) afwijken van het gewone om te zien hoe iets werkt of gewoon omdat het kan?

Door Tweakers user RobIII, dinsdag 24 juni 2014 11:12

-RetroX- schreef op dinsdag 24 juni 2014 @ 11:07:
Is dit niet tweakers? De plek waar we (soms) afwijken van het gewone om te zien hoe iets werkt of gewoon omdat het kan?
En zo maak je een discussie dus kapot... Maar goed; jij je zin: ja dit is Tweakers. Ja, dit is de plek waar we (soms) afwijken van het gewone om te zien hoe iets werkt of gewoon omdat het kan.

*O*

Dit is ook de plek waar mensen zitten die weten waar ze 't over hebben en die je van (goed bedoeld) advies voorzien op 't moment dat je ergens van 't paadje raakt of dreigt te raken en zodoende kunnen helpen problemen te voorkomen waar al hordes mensen je zijn voorgegaan en allemaal op zijn teruggekomen (of die nog steeds in de zandbak zitten spelen).

Maar goed; we vegen straks in de Devschuur wel weer de scherven bij elkaar als er een honderduizendmiljardste topic wordt geopend over "waarom zeurt mijn leverancier over ongeldige XML" en "waarom klapt mijn import proces steeds met een exception als ik Pietje's XML probeer in te lezen".

[Reactie gewijzigd op dinsdag 24 juni 2014 11:15]


Door Tweakers user -RetroX-, dinsdag 24 juni 2014 11:19

RobIII schreef op dinsdag 24 juni 2014 @ 11:12:
[...]
En zo maak je een discussie dus kapot...
Valt mee hoor. Jouw standpunt is dat je alleen iets moet gebruiken wat bewezen is. Mijn standpunt is dat je zelf ook iets mag bouwen om te leren. Dit is een verschil van inzicht maar beiden sluiten elkaar niet uit. Ik heb niet de intentie om jou te overtuigen van mijn standpunt. Aan de andere kant verwacht ik ook niet dat jij in dit geval mij kunt overtuigen aangezien ik het op principele punten wel met je eens ben. We kunnen de discussie prima voortzetten maar ik denk niet dat de reacties van een blogpost daar de meest geschikte plek voor is. Als je aanvullende argumenten wilt delen dan moet je dat zeker doen. De lezers van de reacties kunnen dan zelf hun mening vorming aan de argumenten die reeds gegeven zijn (of nog zullen volgen).
RobIII schreef op dinsdag 24 juni 2014 @ 11:12:
[...]
Maar goed; we vegen straks in de Devschuur wel weer de scherven bij elkaar als er een honderduizendmiljardste topic wordt geopend over "waarom zeurt mijn leverancier over ongeldige XML" en "waarom klapt mijn import proces steeds met een exception als ik Pietje's XML probeer in te lezen".
Goh, met zoveel van die topics zou dan eigenlijk iemand eens een tutorial moeten schrijven...

[Reactie gewijzigd op dinsdag 24 juni 2014 11:26]


Door Tweakers user RobIII, dinsdag 24 juni 2014 11:26

-RetroX- schreef op dinsdag 24 juni 2014 @ 11:19:
Jouw standpunt is dat je alleen iets moet gebruiken wat bewezen is.
Nee, mijn standpunt is helemaal niet dat je "alléén" iets moet gebruiken dat bewezen is. Mijn standpunt is dat als je zelf denkt dat je 't beter kunt je 't ook vooral beter moet doen wil 't nut hebben. En doe je dat niet, no harm done. Als het doet wat je wil dat 't doet: prima, good for you d:)b . We maken allemaal wel eens een ranzige hack of workaround. Maar flemp je baksel dan niet als "tutorial" op internet om "even te laten zien how it's done". Juist beginners nemen alles voor "waar" aan en die help je daarmee allemaal de verkeerde kant op. Je helpt ze dus effectief niet met je tutorial, behalve als je ze de problemen in wil helpen; dan doe je er inderdaad goed aan.
-RetroX- schreef op dinsdag 24 juni 2014 @ 11:19:
Goh, met zoveel van die topics zou dan eigenlijk iemand eens een tutorial moeten schrijven...
You just made my point. Als iemand nou eens een fatsoenlijke tutorial zou schrijven... Juist dit soort tutorials (uit deze blogpost) draagt bij aan dergelijke topics. Get it?

[Reactie gewijzigd op dinsdag 24 juni 2014 11:30]


Door Tweakers user -RetroX-, dinsdag 24 juni 2014 11:37

RobIII schreef op dinsdag 24 juni 2014 @ 11:26:
[...]
Nee, mijn standpunt is helemaal niet dat je "alléén" iets moet gebruiken dat bewezen is.
Mijn fout, dat had ik namelijk in deze passage zo gelezen:
Gebruik altijd een (bewezen) library of functies die in je platform/taal aanwezig zijn en daarvoor dienen; zoals hierboven aangegeven is
RobIII schreef op dinsdag 24 juni 2014 @ 11:26:
You just made my point. Als iemand nou eens een fatsoenlijke tutorial zou schrijven... Juist dit soort tutorials (uit deze blogpost) draagt bij aan dergelijke topics. Get it?
Precies. Kom maar op met die tutorial ;)

Door Tweakers user RobIII, dinsdag 24 juni 2014 11:48

-RetroX- schreef op dinsdag 24 juni 2014 @ 11:37:
Precies. Kom maar op met die tutorial ;)
Ik doe niet veel met PHP, laat staan PHP + XML en ik maak mezelf nu schuldig aan waar ik xleeuwx op wijs; maar omdat 't in ieder geval beter is dan strings aan mekaar lopen plakken post ik 't toch:

PHP:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
$array = ['foo' => 'bar', 'foobar' => 'this & that', 'test' => 'lörëm ïpsum'];

header('Content-Type: text/xml; charset=utf-8');
echo ArrayToXml($array, 'myrootnodename');

function ArrayToXML($array, $root) { 
  $doc = new DOMDocument('1.0', 'utf-8'); 
  //Optional: 
  $doc->formatOutput = true; 
  $doc->preserveWhiteSpace = false;  

  $rootelem = $doc->createElement($root); 
  foreach ($array as $k => $v) { 
    $n = $doc->createElement($k); 
    $n->appendChild($doc->createTextNode($v)); 
    $rootelem->appendChild($n); 
  } 
  $doc->appendChild($rootelem); 
  return $doc->saveXML(); 
}



<?xml version="1.0" encoding="utf-8"?>
<myrootnodename>
  <foo>bar</foo>
  <foobar>this &amp; that</foobar>
  <test>lörëm ïpsum</test>
</myrootnodename>

Gebruik je de utf-8 encoding niet in de constructor van DOMDocument dan zie je meteen dat er correct ge-encode wordt:
<?xml version="1.0"?>
<myrootnodename>
  <foo>bar</foo>
  <foobar>this &amp; that</foobar>
  <test>l&#xF6;r&#xEB;m &#xEF;psum</test>
</myrootnodename>


Met daarbij dus geen garanties (ik ben geen PHP'er) en dus deze disclaimer (die toch niemand leest / wat mee doet). En dan laat ik 't genereren van nested arrays als oefening voor de lezer ;)

Tweakblogs heeft een paar keer de encoding van & vs. &amp; om zeep geholpen; controleer even voor jezelf de output als je denkt dat hier fouten staan...

[Reactie gewijzigd op dinsdag 24 juni 2014 12:11]


Door Tweakers user TIGER79, dinsdag 24 juni 2014 12:16

Nou, hiebij a little food for the discussion :P
http://programmers.stacke...wheel-really-all-that-bad

Maar dat is wel waar ik me altijd achter heb geschaard : waarom weer het iwel uitvinden als er goede, bewezen, volwassen oplossingen zijn in de software wereld ?
Tuurlijk kun je er ook nog eens in gaan neuzen 9indien open source) om wat extra kennis op te doen maar in commerciele projecten wil je dat dus niet ivm tijd en dus kosten...
Ik heb hier een collega die nu pas een keer met XML iets moet doen, ondertussen zijn er tich libraries in C daarvoor maar meneer wou het goed begrijpen en is dus vervolgens 3 weken bezig geweest met het implementeren ervan volgens de w3c richtlijnen en natuurlijk duiken er altijd nog bugs op, wat weer voor vertragingen zorgt bij andere ontwikkelaars omdat zij nou net hun eigen software willen testen die tegen eerdergenoemde xml interface spreekt...

Zonde van de tijd als je het mij vraagt, en heb je dan een betere implementatie ? Nee tuurlijk niet, vol kinderziektes...

Door Tweakers user NightFox89, dinsdag 24 juni 2014 12:37

1. Er zit totaal geen verschil in, daarnaast doe ik bijna nooit zo maar hier was het voor de leesbaarheid iets beter om het op deze manier te doen.
Geen verschil? Komt ie:

PHP heeft wel degelijk verschil tussen een enkele quote en een dubbele. Een enkele wordt direct geplaatst, een dubbele wordt eerst helemaal ontleed om te kijken of er variables instaan. Enkele quotes en dan de variables via concatinatie is vele malen sneller dan variables in strings plaatsen. Bij simpele projectjes kom je dit nog niet tegen, maar wanneer je grotere projecten hebt kan dit al snel veel tijd schelen.

Door Tweakers user RobIII, dinsdag 24 juni 2014 18:42

NightFox89 schreef op dinsdag 24 juni 2014 12:37
Geen verschil? Komt ie:

PHP heeft wel degelijk verschil tussen een enkele quote en een dubbele. Een enkele wordt direct geplaatst, een dubbele wordt eerst helemaal ontleed om te kijken of er variables instaan. Enkele quotes en dan de variables via concatinatie is vele malen sneller dan variables in strings plaatsen. Bij simpele projectjes kom je dit nog niet tegen, maar wanneer je grotere projecten hebt kan dit al snel veel tijd schelen.
Jammer dat je geen plaatjes kunt posten op Tweakblogs comments, maar deze zou goed van pas komen nu: http://riii.nl/awjeez :)

Je overdrijft nu wel een beetje...

PHP:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
$var1 = 'lalala';
$var2 = 'Lorem';
$var3 = 'Ipsum';

$main_iterations = 10;
$iterations = 100000;
$total_test_a = 0;
$total_test_b = 0;

for ($m = 0; $m < $main_iterations; $m++) {
    $start = microtime(true);
    for ($i = 0; $i < $iterations; $i++) {
      $result = "{$var1} Dit is een test {$var2} {$var3}";
    }
    $test_a = microtime(true) - $start;

    $start = microtime(true);
    for ($i = 0; $i < $iterations; $i++) {
      $result = $var1 . ' Dit is een test ' . $var2 . ' ' . $var3;
    }
    $test_b = microtime(true) - $start;

    $total_test_a += $test_a;
    $total_test_b += $test_b;

    echo 'Test A took: ' . number_format($test_a , 8) . ' for ' . $iterations . ' iterations; ' . number_format($test_a / $iterations, 8) . ' p/iteration<br>';
    echo 'Test B took: ' . number_format($test_b , 8) . ' for ' . $iterations . ' iterations; ' . number_format($test_b / $iterations, 8) . ' p/iteration<br>';
}

echo 'Total Test A took: ' . number_format($total_test_a, 8) . ' for ' . $iterations  * $main_iterations . ' iterations<br>';
echo 'Total Test B took: ' . number_format($total_test_b, 8) . ' for ' . $iterations  * $main_iterations . ' iterations<br>';

echo 'Total difference: ' . number_format((1-($test_a / $test_b)) * 100, 8) . '% or ' . number_format((($test_a - $test_b) / ($iterations  * $main_iterations)), 12) . ' p/iteration';


Test A took: 0.04514003 for 100000 iterations; 0.00000045 p/iteration
Test B took: 0.04203391 for 100000 iterations; 0.00000042 p/iteration
Test A took: 0.04560399 for 100000 iterations; 0.00000046 p/iteration
Test B took: 0.04269695 for 100000 iterations; 0.00000043 p/iteration
Test A took: 0.04629087 for 100000 iterations; 0.00000046 p/iteration
Test B took: 0.04414201 for 100000 iterations; 0.00000044 p/iteration
Test A took: 0.04611015 for 100000 iterations; 0.00000046 p/iteration
Test B took: 0.04274511 for 100000 iterations; 0.00000043 p/iteration
Test A took: 0.04771996 for 100000 iterations; 0.00000048 p/iteration
Test B took: 0.04325104 for 100000 iterations; 0.00000043 p/iteration
Test A took: 0.04642820 for 100000 iterations; 0.00000046 p/iteration
Test B took: 0.04301214 for 100000 iterations; 0.00000043 p/iteration
Test A took: 0.04643106 for 100000 iterations; 0.00000046 p/iteration
Test B took: 0.04224396 for 100000 iterations; 0.00000042 p/iteration
Test A took: 0.04559302 for 100000 iterations; 0.00000046 p/iteration
Test B took: 0.04209709 for 100000 iterations; 0.00000042 p/iteration
Test A took: 0.04507589 for 100000 iterations; 0.00000045 p/iteration
Test B took: 0.04261398 for 100000 iterations; 0.00000043 p/iteration
Test A took: 0.04512501 for 100000 iterations; 0.00000045 p/iteration
Test B took: 0.04225802 for 100000 iterations; 0.00000042 p/iteration
Total Test A took: 0.45951819 for 1000000 iterations
Total Test B took: 0.42709422 for 1000000 iterations
Total difference: -6.78447104% or 0.000000002867 p/iteration


Het scheelt je, per "concatenatie" dus 0.000000002867 seconden; op een totaal van 1.000.000(!) "concatenaties" is 't verschil welgeteld 0,032 seconden. Dat moet wel een verdomd "groot project" zijn dan ;)

Seriously: als er iets een nutteloze micro-optimalisatie is, is het dat wel. Doorsnee genomen: maak in "je grotere projecten" waar jij 't over hebt 1 query een tikkie sneller en je haalt er 't tienvoudige uit. Als je werkelijk op dit niveau zit te "optimaliseren" kun je beter overwegen 100 euro uit te geven aan 'n tikkeltje snellere processor; hardware is nog altijd een factor VEEL goedkoper dan ontwikkeltijd.

Edit:
En ik zie net dat andere PHP versies (ik heb bovenstaande getest op 5.5.10) zoals 5.2 en 5.3 en 5.4 in een aantal gevallen zelfs sneller zijn op test A ("met de {variabelen} in de string"). Overigens ook even lezen: Programmers Need To Learn Statistics Or I Will Kill Them All want ik heb 'n klein beetje slordig kort-door-de-bocht gemeten :P Het uiteindelijke punt is dan ook: lood om oud ijzer; maak je niet druk over " of ', spaar je de moeite, etc. Dat er andere, wél valide, redenen zijn om " boven ' te verkiezen (of andersom) is iets anders.

[Reactie gewijzigd op dinsdag 24 juni 2014 19:27]


Door Tweakers user Xantios, dinsdag 24 juni 2014 20:31

Ja heel lollig dat tijdsverschil.
probeer het eens met "Lorem ipsum {$dolor} sit {$frietMet}" ;-) volgens mij zat daar nou net het manko in als ik mij niet vergis.

En buiten dat, voor de leesbaarheid ben ik ook van kamp 'enkel-quote'

Verder is er natuurlijk genoeg te zeggen over deze functie, maar al met al vind ik het eigenlijk nog best leuk verzonnen.

En als je nou net alleen dit specifieke stukje XML nodig hebt denk ik dat het nog best aardig werkt. om daar nou een hele lib voor uit de kast te gaan trekken lijkt me ook wel weer beetje veel van het goeie.

Door Tweakers user RobIII, dinsdag 24 juni 2014 20:47

Xantios schreef op dinsdag 24 juni 2014 20:31
Ja heel lollig dat tijdsverschil.
probeer het eens met "Lorem ipsum {$dolor} sit {$frietMet}" ;-) volgens mij zat daar nou net het manko in als ik mij niet vergis.
Voordat je zoiets beweert kun je 't natuurlijk zélf ook even testen, maar hey, ik ben de lulligste niet.

Het was:

$result = "{$var1} Dit is een test {$var2} {$var3}";

En daar heb ik nu van gemaakt:

$result = "{$var1} Dit is {$i} een test {$var2}";

Dit zodat:
a) er "in het midden van de string" iets wordt ingevuld (i.t.t. alleen aan 't begin en 't einde Hoewel dat, technically, al niet zo was want er staat een spatie tussen var2 en var 3)

b) er een 'dynamische waarde' gebruikt wordt ($i) i.p.v. 3 "constanten":

PHP:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
$var1 = 'lalala'; 
$var2 = 'Lorem'; 

$main_iterations = 10; 
$iterations = 100000; 
$total_test_a = 0; 
$total_test_b = 0; 

for ($m = 0; $m < $main_iterations; $m++) { 
    $start = microtime(true); 
    for ($i = 0; $i < $iterations; $i++) { 
      $result = "{$var1} Dit is {$i} een test {$var2}"; 
    } 
    $test_a = microtime(true) - $start; 

    $start = microtime(true); 
    for ($i = 0; $i < $iterations; $i++) { 
      $result = $var1 . ' Dit is ' . $i . ' een test ' . $var2; 
    } 
    $test_b = microtime(true) - $start; 

    $total_test_a += $test_a; 
    $total_test_b += $test_b; 

    echo 'Test A took: ' . number_format($test_a , 8) . ' for ' . $iterations . ' iterations; ' . number_format($test_a / $iterations, 8) . ' p/iteration<br>'; 
    echo 'Test B took: ' . number_format($test_b , 8) . ' for ' . $iterations . ' iterations; ' . number_format($test_b / $iterations, 8) . ' p/iteration<br>'; 
} 

echo 'Total Test A took: ' . number_format($total_test_a, 8) . ' for ' . $iterations  * $main_iterations . ' iterations<br>'; 
echo 'Total Test B took: ' . number_format($total_test_b, 8) . ' for ' . $iterations  * $main_iterations . ' iterations<br>'; 

echo 'Total difference: ' . number_format((1-($test_a / $test_b)) * 100, 8) . '% or ' . number_format((($test_a - $test_b) / ($iterations  * $main_iterations)), 12) . ' p/iteration';


Test A took: 0.06604314 for 100000 iterations; 0.00000066 p/iteration
Test B took: 0.06066799 for 100000 iterations; 0.00000061 p/iteration
Test A took: 0.07067084 for 100000 iterations; 0.00000071 p/iteration
Test B took: 0.06114101 for 100000 iterations; 0.00000061 p/iteration
Test A took: 0.06492996 for 100000 iterations; 0.00000065 p/iteration
Test B took: 0.05989790 for 100000 iterations; 0.00000060 p/iteration
Test A took: 0.06408286 for 100000 iterations; 0.00000064 p/iteration
Test B took: 0.06083322 for 100000 iterations; 0.00000061 p/iteration
Test A took: 0.06401396 for 100000 iterations; 0.00000064 p/iteration
Test B took: 0.05978894 for 100000 iterations; 0.00000060 p/iteration
Test A took: 0.06418395 for 100000 iterations; 0.00000064 p/iteration
Test B took: 0.05982399 for 100000 iterations; 0.00000060 p/iteration
Test A took: 0.06466007 for 100000 iterations; 0.00000065 p/iteration
Test B took: 0.05989003 for 100000 iterations; 0.00000060 p/iteration
Test A took: 0.06560588 for 100000 iterations; 0.00000066 p/iteration
Test B took: 0.05888486 for 100000 iterations; 0.00000059 p/iteration
Test A took: 0.06325507 for 100000 iterations; 0.00000063 p/iteration
Test B took: 0.05929589 for 100000 iterations; 0.00000059 p/iteration
Test A took: 0.06323481 for 100000 iterations; 0.00000063 p/iteration
Test B took: 0.05922794 for 100000 iterations; 0.00000059 p/iteration
Total Test A took: 0.65068054 for 1000000 iterations
Total Test B took: 0.59945178 for 1000000 iterations
Total difference: -6.76515578% or 0.000000004007 p/iteration


Totaal geen verschil dus. En haal ik niet genoeg artikelen in die post aan die (ook) beweren (én aantonen) dat 't verschil verwaarloosbaar is? (Het is, best case scenario, meetbaar*, maar dat maakt 't niet minder verwaarloosbaar).

* Onder verschillende PHP versies wil test A nog wel eens beter performen dan test B en omgekeerd; either way scheelt 't mekaar niks (again: meetbaar, maar verwaarloosbaar).
Xantios schreef op dinsdag 24 juni 2014 20:31En buiten dat, voor de leesbaarheid ben ik ook van kamp 'enkel-quote'
Dat is een hele andere reden (en die haalde ik ook al aan) en die is stukken beter verdedigbaar dan "want performance!!11". Of je dan in het 'single quote' of 'double quote' kamp zit: couldn't care less; ieder z'n meug.
Xantios schreef op dinsdag 24 juni 2014 20:31
Verder is er natuurlijk genoeg te zeggen over deze functie, maar al met al vind ik het eigenlijk nog best leuk verzonnen.
Best leuk verzonnen: maybe. Nuttig? Nee. Gevaarlijk? Ja. De beste manier? Nee. De juiste manier? Nee. "Tutorial waardig"? Nee, hell no.
Xantios schreef op dinsdag 24 juni 2014 20:31
En als je nou net alleen dit specifieke stukje XML nodig hebt denk ik dat het nog best aardig werkt. om daar nou een hele lib voor uit de kast te gaan trekken lijkt me ook wel weer beetje veel van het goeie.
Again; ik ben geen PHP'er, maar zit die XML meuk niet gewoon in PHP ingebakken? En zo nee: wat kost 't je nou helemaal? Een paar Kb schijfruimte? Poehee! Met al die terabytes tegenwoordig moet je inderdaad oppassen dat zo'n lib van 250Kb (geen idee hoe "groot" 'ie is) je de kop niet kost!

Serieus? Is dat anno 2014 nog een argument? "een hele lib voor uit de kast [...] gaan trekken"? :D _O-

Maar goed; ik ben er klaar mee. Ik praat tegen de muur en ik heb er zelf geen baat bij jullie wijzer te maken dus waar doe ik 't voor? Iedereen roept vanalles maar bronnen / onderbouwing / metingen / whatever ho maar. :w

[Reactie gewijzigd op dinsdag 24 juni 2014 21:55]


Door Tweakers user xleeuwx, woensdag 25 juni 2014 10:13

Ik heb een stuk van de tutorail herschreven en de validatie toegevoegd. Deze is nu volgens de W3.

De keys die numeric zijn krijgen een prefix "num_". Als dit niet gewenst is kan er natuurlijk een error voor in de plaats komen.

En @RobIII die test geniaal :)

[Reactie gewijzigd op woensdag 25 juni 2014 10:15]


Door Tweakers user RobIII, woensdag 25 juni 2014 17:08

Ik snap alleen (nog) niet waarom je loopt te ouwehoeren met regexen ("illegal characters"); gooit die "SimpleXML" niet gewoon een exception als je probeert een ongeldige node te creeëren?

Zo nee: wat een boutlibrary :X Is de DOMDocument-variant-dinges-library niet beter?
Zo ja: waarom loop je dan nog te regexen?

______________________________
edit
Holy shit :F :X
Boutlibrary it is...

PHP:
1
2
3
$xml = new SimpleXMLElement('<?xml version="1.0" encoding="utf-8" ?><root/>'); 
$xml->addChild('foo bar baz \\ lorem=ipsum"dolor sit\'amet/'); 
echo $xml->asXml();


<?xml version="1.0" encoding="utf-8"?>
<root><foo bar baz \ lorem=ipsum"dolor sit'amet//></root>

Mis ik nou iets en moet er één of andere optie aan staan of is SimpleXML écht zo gaar? :X Het zal wel niet voor niets "Simple" heten :+ (Then again: ik heb me niet héél erg verdiept in de documentatie; ik zal de dikke vette disclaimer vast ergens gemist hebben...)

DOM lijkt 't wel goed te doen:

PHP:
1
2
$xml = new DOMDocument("1.0", "utf8");
$elem = $xml->createElement('foo bar baz \\ lorem=ipsum"dolor sit\'amet');


Fatal error:  Uncaught exception 'DOMException' with message 'Invalid Character Error'

*O*
/edit
______________________________

Sowieso is je "validatie" niet "volgens W3" (en zo zie je maar hoe lastig 't is zoiets *goed* te implementeren). Want hier staat héél iets anders dan je "validatie" doet.

[Reactie gewijzigd op woensdag 25 juni 2014 17:35]


Door Tweakers user xleeuwx, donderdag 26 juni 2014 15:38

Inderdaad je DOMDocument-variant-dinges-library werkt een stuk beter kwa error handling.

Door Tweakers user RobIII, zaterdag 28 juni 2014 01:06

xleeuwx schreef op donderdag 26 juni 2014 15:38
Inderdaad je DOMDocument-variant-dinges-library werkt een stuk beter kwa error handling.
Error handling dien je, as always, zelf te doen. Dat je 't throwen van errors over laat aan de DOMDocument (en die dat dus blijkbaar beter doet dan SimpleXML) is iets anders ;)

[Reactie gewijzigd op zaterdag 28 juni 2014 01:06]


Door Tweakers user Precision, zondag 29 juni 2014 22:46

[quote]xleeuwx schreef op dinsdag 24 juni 2014 @ 09:21:
[...]


1. Er zit totaal geen verschil in, daarnaast doe ik bijna nooit zo maar hier was het voor de leesbaarheid iets beter om het op deze manier te doen.
[...]
strings worden in bepaalde talen behandeld als immutable, je kunt het object niet wijzigen maar de reference wel wijzigen. Wat betekent dat je een nieuwe instance maakt. Wat ik iedereen hier zo posten is het verschil in tijd, maar wat met het verschil in memory usage?

Reageren is niet meer mogelijk