Collections Illuminate vs tableaux PHP

Les détracteurs de PHP s'en prennent toujours à lui pour diverses raisons, mais l'une des cibles les plus faciles est la laideur du code. Certaines personnes peuvent ne pas être d'accord avec l'importance de la propreté et de la « beauté » du code, mais lorsqu'il s'agit de maintenir des bases de code sur le long terme, vous pouvez faire gagner beaucoup de temps à votre équipe en ayant un code facile à lire.

Lorsque j'étais chez Apple, j'ai développé un écosystème d'applications financières utilisées par les parties prenantes internes. Au fil des années, j'ai constamment intégré de nouveaux développeurs dans les outils pour aider à la maintenance générale ou aux améliorations. L'un des principaux enseignements de cette époque est l'importance de pouvoir lire son code en langage naturel.

Il est intéressant de constater que la plupart des codes sont écrits de telle manière qu'il faut en lire une partie importante, puis revenir au début pour bien comprendre ce qui se passe. L'utilisation d'un langage ou d'API plus expressifs lors de l'écriture de code peut réduire considérablement les délais d'intégration et de démarrage des nouveaux développeurs.

C'est là que les collections brillent. Les collections Laravel prennent en charge des parcours de tableaux complexes et les rendent incroyablement faciles à lire et à comprendre. Votre code devient une chaîne de commandes qui se lit comme suit : « Filtrer ce tableau pour n'inclure que les mots commençant par a, puis mapper le montant du coût à la ligne, et enfin réduire cela à une somme de tous les coûts. » Il est très facile de sous-estimer l'importance d'écrire votre code avec un langage plus expressif, mais une fois que vous en avez pris l'habitude, il est difficile d'imaginer que quoi que ce soit d'autre soit acceptable.

Bien entendu, la lisibilité ne doit pas se faire au détriment des performances. Il est donc important de veiller à toujours faire des choix judicieux et à ne donner la priorité à la lisibilité que lorsque cela est approprié. Nous devons toujours comprendre ce qui se passe en coulisses et être pleinement conscients des compromis auxquels nous sommes confrontés dans la manière dont nous abordons nos solutions. Il ne sert à rien que notre code soit lisible s'il prend une seconde de plus qu'une solution moins lisible.

Plongeons-nous dans un examen approfondi des tableaux PHP par rapport aux collections et comparons les performances entre les deux.

Lisibilité des collections Laravel

L'un des principaux avantages de l'utilisation des collections Laravel est leur syntaxe fluide, qui permet d'enchaîner les méthodes. Cela donne un code propre et lisible, car vous pouvez effectuer plusieurs opérations dans une séquence sans avoir besoin de variables temporaires ou d'appels de fonctions imbriquées complexes.

Comparons ci-dessous certaines des fonctions de manipulation de tableaux couramment utilisées pour voir comment PHP se compare aux collections dans un exemple très simple.

Filtre

PHP

 array_filter($data, function($row) { return substr($row, 0, 1) === "a"; });

Collections

 $data->filter(function($row) { return substr($row, 0, 1) === "a"; });

Recherche

PHP

 array_search(function($row) { return substr($row, 0, 1) === "a"; }, $data);

Collections

 $data->search(function($row) { return substr($row, 0, 1) === "a"; });

Carte

PHP

 array_map(function($row) { return "test"; }, $data);

Collections

 $data->map(function($row) { return "test"; });

Trier

PHP

 sort($data);

Collections

 $data->sort();

Chaque

PHP

 foreach($loop as $item) { $doSomething = true; }

Collections

 $data->each(function($row) { return "test"; });

Réduire

PHP

 array_reduce($data, function($carry, $row) { return $carry + strlen($row); });

Collections

 $data->reduce(function($carry, $row) { return $carry + strlen($row); });

Épissure

PHP

 array_splice($data, count($data)/2);

Collections

 $data->splice(count($data)/2);

Tous ensemble (PHP)

 $data = array_filter($data, function($row) { return substr($row, 0, 1) === "a"; }); $data = array_search(function($row) { return substr($row, 0, 1) === "a"; }, $data); $data = array_map(function($row) { return "test"; }, $data); sort($data); foreach($loop as $item) { $doSomething = true; } $sum = array_reduce($data, function($carry, $row) { return $carry + strlen($row); });

Tous ensemble (Collections)

 $sum = $data->filter(function($row) { return substr($row, 0, 1) === "a"; })->search(function($row) { return substr($row, 0, 1) === "a"; })->map(function($row) { return "test"; })->sort() ->each(function($row) { return "test"; })->reduce(function($carry, $row) { return $carry + strlen($row); });

Comparaison

Avec une approche aussi simple, il ne semble pas y avoir de compromis énorme en termes de lisibilité pour chaque fonction individuelle, bien que lorsque vous considérez l'exemple où vous avez besoin qu'elles soient toutes appliquées à un seul tableau, vous pouvez clairement voir qu'il est plus concis et plus facile à lire lors de l'utilisation des méthodes enchaînées dans une collection.

Au lieu de devoir constamment écraser votre variable, puis définir une nouvelle variable pour la sortie à la fin, nous pouvons simplement enchaîner chaque commande jusqu'à ce que nous obtenions la sortie souhaitée. Les collections sont certainement plus faciles à lire à mesure que votre code devient plus complexe.

Performance

J'ai pris les exemples ci-dessus et généré des données de test pour tenter de déterminer si les collections étaient plus ou moins performantes que les fonctions PHP standard.

Chaque tableau contenait 100 000 chaînes aléatoires comme éléments, et j'ai exécuté chaque fonction 100 fois. Au final, nous avons calculé la moyenne de tous les temps de réponse.

Les résultats finaux sont ci-dessous :

 ========== Tests Complete (ms) ========== php filter: 5.07 collect filter: 6.49 ======================= php search: 0.79 collect search: 0 ======================= php map: 3.45 collect map: 4.18 ======================= php sort: 25.27 collect sort: 11.18 ======================= php each: 1.03 collect each: 6.96 ======================= php reduce: 2.78 collect reduce: 7.75 ======================= php splice: 1 collect splice: 0.74 =======================

Conclusion

Comme vous pouvez le constater clairement, même si nous gagnons beaucoup en lisibilité grâce aux collections, nous perdons une quantité importante de performances dans certains domaines clés.

Filter , Map , Foreach et Reduce sont tous plus rapides avec les fonctions PHP standard. Foreach et Reduce présentent en fait des différences incroyablement significatives. Search , Sort et Splice montrent tous que Collections est le gagnant, et Sort permet en fait de gagner énormément de temps.

Il est également important de noter que vous devrez créer chaque collection à partir d'un tableau construit, ce qui ajoute un tout petit peu de surcharge à la configuration de la collection pour commencer, mais même avec cette petite quantité de travail et de temps supplémentaires, les résultats sont assez clairs.

À mon avis (et ce n'est qu'un avis basé sur ces résultats), si les performances sont une préoccupation majeure, je m'en tiendrais certainement aux fonctionnalités PHP standard pour les boucles Foreach et probablement à la même chose pour tous les besoins de Reduce . Si vous devez effectuer un tri sur de grands ensembles de données, Collections est clairement la bonne solution. Les autres sont si proches que cela ressemble vraiment à une préférence personnelle.

À ce stade, je dirais que les collections sont toujours plus faciles à lire et à entretenir.

Bien évidemment, vous devez prendre ces informations en compte et prendre votre propre décision en toute connaissance de cause. Cependant, si vous êtes comme moi, je pense que vous vous retrouverez à glisser des collections pour bon nombre des fonctions ci-dessus. Mais je pense que je vais réduire mon utilisation de →each et →reduce lorsque cela est approprié à l'avenir !