PHP: Est-il préférable de concaténer sur 1 ligne ou plusieurs lignes? Ou y a-t-il une différence?

Question

Y a-t-il une différence ou est-il meilleur que l'autre des éléments suivants:

$var = '';
...
$var .= 'blah blah';
$var .= $var2;
$var .= 'blah blah';

Ou

$var = '';
...
$var .= 'blah blah' . $var2 . 'blah blah';

Y a-t-il une différence de vitesse ou y a-t-il une raison pour laquelle vous choisiriez l'une plutôt que l'autre?

Answer 1

Il y a une petite différence si vous faites écho à la chaîne.

echo $var1,$var2,$var3 // comma (echo with multiple arguments)

est légèrement plus rapide que

echo $var1.$var2.$var3 // dot   (concat and echo)

Answer 2

PEZ et Topbit sont corrects. Je veux juste signaler quelque chose qui, à mon avis, a l'air meilleur que ce qui a été vu ici:

$var  = "line 1 \n";
$var .= "line 2 \n";

versus

$var = "line 1 \n"
     . "line 2 \n";

Je préfère de loin le second au premier car il est évident que votre résultat est la chaîne $ var. Il empêche également les bugs stupides tels que:

$var  = "line 1 \n";
$var .= "line 2 \n";
$vat .= "line 3 \n";
$var .= "line 4 \n";

Answer 3

Peu importe, quelques chaînes courtes. Utilisez ce qui est plus clair à lire.

Mais si vous en avez beaucoup (disons des milliers) pas trop courtes, vous voudrez probablement les garder dans un tableau et les joindre. (En réalité, il est souvent aussi facile de lire ce code que de concaténer les chaînes avec ". = =", Vous ne sacrifiez donc pas la clarté sur l'autel des performances.)

EDIT: Je ne pense pas que ma façon de penser ci-dessus soit valide. Les chaînes de PHP sont mutables, non?

Answer 4

Ne fera pas une différence. Les deux sont de la concaténation, alors ce qui est le plus facile à lire est ce que vous devriez utiliser.

Si vous recherchez les meilleures performances, essayez d'utiliser un tableau, puis de l'imploser lorsque vous avez terminé.

$var = array();
$var[] = "line 1\n";
$var[] = "line 2\n";
$var[] = "line 3";
$var = implode('', $var);

Quelle que soit votre méthode, la différence de vitesse sera négligeable, à moins que vous ne travailliez avec des milliers de grosses chaînes.

Answer 5

Pour tout ce que vous concaténez manuellement dans le code, les performances importent probablement peu, la lisibilité est donc primordiale. Pour moi, cela signifie souvent que vous utilisez Heredoc syntaxe. Je n'aime pas la façon dont il casse la structure d'indentation, mais c'est particulièrement agréable lorsque vous souhaitez insérer des sauts de ligne et / ou des tabulations correctement dans vos chaînes.

Answer 6

Je ne pense pas que vous remarquerez une situation aussi courte. Je décide généralement pour des raisons de lisibilité que je vais utiliser. Je ne partage que deux situations, sinon une seule ligne:

a) Créer une réponse sur plusieurs lignes afin que le code imite quelque peu ce que l'utilisateur verra. J'ai trouvé qu'il était plus facile d'attraper des fautes de frappe et des erreurs de cette façon.

$var  = "line 1 \n";
$var .= "line 2 \n";

b) longueur de ligne. Si la ligne déborde de la fenêtre, je vais généralement la séparer pour ne pas avoir à aller au bout de la ligne pour lire la fin. La plupart des langues supportent un caractère de continuation de ligne, je n'ai donc pas vraiment besoin de le casser physiquement dans le code, mais juste une habitude que j'ai depuis que je travaille dans certaines langues qui ne l'ont pas.

Answer 7

Le moyen le plus rapide d'obtenir une grande quantité de données dans une seule chaîne consiste à mettre en mémoire tampon la sortie pour capturer la sortie renvoyée à l'écho.

ob_start();
/* many echos. For example, in a loop */
$outString = ob_get_contents(); // get the complete string
ob_end_clean();

En général, il est peu probable que la vitesse de votre programme change de manière significative. Faites donc clairement apparaître ce que vous faites, car vous devez revenir le corriger ultérieurement de toute façon. La lisibilité est roi.

Answer 8

Il n'y a pas de différence significative. C'est juste une question de préférence de codage.

Answer 9

Je pensais que créer un tableau puis imploser pourrait être le moyen le plus rapide. J'avais tort! Cependant, faire $ str = $ str + $ bla est vraiment lent par ordre de grandeur! Ce n'est important que si vous faites une tonne de concaténations. Voici mon code de test:

<?php

function doit($n) {

    $str2concat = 'Esta es una prueba. ¿Cuál manera es más rápida?';

    $str = '';

    // option 1
    $start = microtime(true);

    for( $i=0; $i <= $n; $i++ ) {
        $str .= $str2concat;
    }

    $end = microtime(true);
    echo " Concat: $n Iterations, duration:" . ($end-$start) . "\n";

    // option 2
    $str = '';
    $start = microtime(true);

    for( $i=0; $i <= $n; $i++ ) {
        $str = $str . $str2concat;
    }

    $end = microtime(true);
    echo "Concat2: $n Iterations, duration:" . ($end-$start) . "\n";

    // option 3
    $str = [];
    $start = microtime(true);

    for( $i=0; $i <= $n; $i++ ) {
        $str[] = $str2concat;
    }

    $str = implode( $str );
    $end = microtime(true);
    echo "Implode: $n Iterations, duration:" . ($end-$start) . "\n\n";

}

doit( 5000 );
doit( 10000 );
doit( 100000 );

Voici les résultats que j'ai obtenus:

 Concat: 5000 Iterations, duration:0.0031819343566895
Concat2: 5000 Iterations, duration:0.41280508041382
Implode: 5000 Iterations, duration:0.0094010829925537

 Concat: 10000 Iterations, duration:0.0071289539337158
Concat2: 10000 Iterations, duration:1.776113986969
Implode: 10000 Iterations, duration:0.013410091400146

 Concat: 100000 Iterations, duration:0.06755805015564
Concat2: 100000 Iterations, duration:264.86760401726
Implode: 100000 Iterations, duration:0.12707781791687