Comprendre le pass-by-by-référence de PHP: performance et pièges

Pass-by-Reference dans PHP n'améliore pas les performances avec de grands tableaux ou objets en raison des poignées de copie-écriture et d'objets, donc il ne doit pas être utilisé à cette fin; 1. Utilisez Pass-by-Reference uniquement lorsque vous devez modifier la variable d'origine, telles que l'échange de valeurs ou le renvoi de plusieurs valeurs via des paramètres de fonction; 2. Évitez-le pour les gains de performance car le PHP moderne optimise déjà le passage de la valeur; 3. Soyez prudent des effets secondaires, des références persistantes dans les boucles et des modifications involontaires; 4. Préférez le renvoi de nouvelles valeurs pour le code plus propre, plus sûr et plus testable; 5. Références de réserve pour les cas rares où le profilage montre un avantage ou le cas échéant par un code externe, les traitant comme un outil pointu - utile lorsque cela est nécessaire mais dangereux s'il est surutilisé.

La fonction de référence de PHP peut être un outil puissant lorsqu'elle est utilisée correctement, mais elle est souvent mal comprise et mal appliquée, conduisant à des bogues confus ou à de fausses hypothèses sur les performances. Décomposons le fonctionnement du passage par référence en PHP, quand il aide, et où il peut se retourner.

Qu'est-ce que le pass-par-référence?

En PHP, les variables sont normalement transmises par valeur. Cela signifie que lorsque vous transmettez une variable à une fonction, une copie de sa valeur est faite. Toute modification à l'intérieur de la fonction n'affecte pas la variable d'origine.

Pass-by-Reference, en revanche, permet à une fonction de modifier directement la variable d'origine. Vous indiquez cela en utilisant le & symbole dans la définition du paramètre de fonction:

 Fonction Incrément (& $ valeur) {
    $ valeur;
}

$ nombre = 5;
incrément (numéro $);
numéro d'écho $; // Sorties: 6

Ici, $number est passé par référence, donc la fonction la modifie directement.

Performance: cela aide-t-il?

Une idée fausse commune est que le passage de grands tableaux ou objets par référence améliore considérablement les performances en évitant la copie de la mémoire. Mais cela est largement dépassé en PHP moderne.

Depuis PHP 5 et surtout PHP 7, PHP utilise des poignées de copie-écriture et d'objet:

• Arrays et chaînes : PHP ne copie pas réellement de grandes variables lors du passage par valeur à moins qu'elles ne soient modifiées. Grâce à la sémantique de copie sur l'écriture, les données sont partagées jusqu'à ce qu'une écriture se produise.
• Objets : à partir de PHP 5, les objets sont passés par référence par défaut (plus précisément, par la poignée des objets), donc l'utilisation & les paramètres d'objet n'est pas nécessaire et n'améliore pas les performances.

Donc, pour la plupart des cas:

• Passer de grands tableaux par référence ne rendra pas votre code plus rapidement .
• Le gain de performance est négligeable ou inexistant dans la pratique.
• Le moteur optimise déjà la valeur qui passe efficacement.

Ce n'est que dans de rares cas - comme modifier à plusieurs reprises un grand tableau à l'intérieur de plusieurs fonctions - une première référence offre un minuscule bord, mais la lisibilité et la maintenabilité devraient venir en premier.

Pièges et gatchas communs

Bien que les références puissent être utiles, elles introduisent la complexité et les bogues subtils.

1. Effets secondaires involontaires

Étant donné que les références permettent aux fonctions de modifier la variable d'origine, il peut rendre le code plus difficile à raisonner:

 Processus de fonction (& $ items) {
    tri ($ items);
}

$ list = [3, 1, 2];
processus ($ list);
// $ La liste est maintenant triée - peut-être que vous ne vous y attendez pas!

Cet effet secondaire n'est évident que si vous vérifiez la définition de la fonction. Il brise l'attente que les fonctions ne modifient pas les entrées.

2. Les références persistent dans les boucles

L'un des pièges les plus notoires concerne foreach et références:

 $ array = [1, 2, 3];
foreach ($ array as & $ valeur) {
    $ valeur * = 2;
}
// $ Value fait toujours référence au dernier élément!

foreach ($ array as $ value) {
    // Cela écrasera le dernier élément!
}
print_r ($ array); // Le dernier élément peut être changé de façon inattendue

Toujours dénoncé la référence après la boucle:

 unset ($ valeur);

3. Renvoi des références (utilisation avancée)

Vous pouvez retourner des références, mais c'est rare et risqué:

 fonction & getStaticValue () {
    STATIQUE $ valeur = 0;
    retour $ valeur;
}

$ ref = & getStaticValue ();
$ ref = 42;
echo getStaticValue (); // Sorties: 42

Cela peut être utile pour implémenter certains modèles (comme l'accès à la propriété Singleton), mais il est facile de créer un code strict et difficile à tester.

Quand devriez-vous utiliser pas-par-référence?

Utilisez le pass-par-référence uniquement lorsque:

• Vous devez renvoyer plusieurs valeurs à partir d'une fonction:

   Swap de fonction (& $ a, & $ b) {
      $ temp = $ a;
      $ a = $ b;
      $ b = $ temp;
  }

• Vous travaillez avec des API ou des cadres externes qui l'exigent.
• Vous implémentez le code et le profilage critiques de performances montrent un réel avantage (rare).

Sinon, préférez les valeurs de retour:

 fonction processData ($ data) {
    // Modifier et renvoyer une nouvelle valeur
    return array_map ('Trim', $ data);
}

C'est plus propre, plus sûr et plus facile à tester.

Fin de compte

Pass-by-Reference en PHP n'est pas un raccourci de performance. Le moteur gère déjà efficacement les grandes données. La mauvaise utilisation des références conduit à des effets secondaires, des bogues et du code difficiles à déboguer.

Utilisez-le avec parcimonie et uniquement lorsque l'intention est claire: la modification de la variable d'origine est l'objectif explicite. Dans la plupart des cas, adoptez l'immuabilité et renvoyez de nouvelles valeurs à la place.

Fondamentalement, traitez & comme un outil pointu - utile dans les bonnes mains, dangereux lorsqu'il est surutilisé.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!