Classes vs tableaux 2D
https://stackoverflow.com/questions/24130
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Qu'est-ce qu'il est préférable d'utiliser en PHP, un tableau 2D ou une classe ?J'ai inclus un exemple de ce que je veux dire par là.
// Using a class
class someClass
{
public $name;
public $height;
public $weight;
function __construct($name, $height, $weight)
{
$this -> name = $name;
$this -> height = $height;
$this -> weight = $weight;
}
}
$classArray[1] = new someClass('Bob', 10, 20);
$classArray[2] = new someClass('Fred', 15, 10);
$classArray[3] = new someClass('Ned', 25, 30);
// Using a 2D array
$normalArray[1]['name'] = 'Bob';
$normalArray[1]['height'] = 10;
$normalArray[1]['weight'] = 20;
$normalArray[2]['name'] = 'Fred';
$normalArray[2]['height'] = 15;
$normalArray[2]['weight'] = 10;
$normalArray[3]['name'] = 'Ned';
$normalArray[3]['height'] = 25;
$normalArray[3]['weight'] = 30;
En supposant que quelqu'un ne montre pas que les cours sont trop lents, il semble que la classe gagne.
Je n'ai aucune idée de la réponse que je devrais accepter, je viens de les voter toutes.
Et j'ai maintenant écrit deux pages presque identiques, une utilisant le tableau 2D (écrit avant la publication de cette question) et maintenant une utilisant une classe et je dois dire que la classe produit un code beaucoup plus agréable.Je n'ai aucune idée de la surcharge qui sera générée, mais je doute que cela rivalise avec l'amélioration du code lui-même.
Merci de m'avoir aidé à devenir un meilleur programmeur.
La solution
La "classe" que vous avez construite ci-dessus est celle que la plupart des gens utiliseraient pour structurer pour dans d'autres langues.Je ne suis pas sûr des implications en termes de performances en PHP, même si je soupçonne que l'instanciation des objets est probablement plus coûteuse ici, ne serait-ce que d'un petit peu.
Ceci étant dit, si le coût est relativement faible, il EST un peu plus facile de gérer les objets, à mon avis.
Je dis seulement ce qui suit en fonction du titre et de votre question, mais :Gardez à l’esprit que les classes offrent également l’avantage des méthodes et du contrôle d’accès.Donc, si vous vouliez vous assurer que les gens ne modifient pas les pondérations en nombres négatifs, vous pourriez faire en sorte que weight champ privé et fournir des méthodes d'accès, comme getWeight() et setWeight().À l'intérieur setWeight(), vous pouvez effectuer une vérification de la valeur, comme ceci :
public function setWeight($weight)
{
if($weight >= 0)
{
$this->weight = $weight;
}
else
{
// Handle this scenario however you like
}
}
Autres conseils
Cela dépend exactement de ce que vous entendez par « mieux ».J'opterais pour la méthode orientée objet (en utilisant des classes) car je trouve que cela permet d'obtenir un code plus propre (du moins à mon avis).Cependant, je ne sais pas quelles pourraient être les pénalités de vitesse pour cette option.
En général, je respecte cette règle :
1) Faites-en une classe si plusieurs parties de votre application utilisent la structure de données.
2) Faites-en un tableau 2D si vous l'utilisez pour un traitement rapide des données dans une partie de votre application.
C'est à la vitesse que je pense principalement, pour quelque chose de plus complexe que ce que j'ai ici, j'opterais probablement pour des cours, mais la question est : quel est le coût d'un cours ?
Cela semble être une optimisation prématurée.De toute façon, votre application ne subira aucun impact sur les performances du monde réel, mais l'utilisation d'une classe vous permet d'utiliser des méthodes getter et setter et sera généralement meilleure pour l'encapsulation et la réutilisation du code.
Avec les tableaux que vous engagez dans un code plus difficile à lire et à maintenir, vous ne pouvez pas tester le code aussi facilement et avec une bonne structure de classes, les autres développeurs devraient trouver plus facile à comprendre s'ils doivent le prendre en charge.
Et lorsque plus tard vous aurez besoin d’ajouter d’autres méthodes pour les manipuler, vous n’aurez pas d’architecture à étendre.
La classe que vous avez n'est pas une vraie classe en termes OO - elle vient d'être construite pour occuper l'espace des variables d'instance.
Cela dit - il n'y a probablement pas beaucoup de problème avec la vitesse - c'est juste une question de style dans votre exemple.
Ce qui est intéressant - c'est que si vous construisiez l'objet pour être une véritable classe "personne" - et que vous réfléchissiez aux autres attributs et actions que vous pourriez souhaiter de la classe personne - alors vous remarqueriez non seulement une performance de style - l'écriture de code - mais accélère également les performances.
Si votre code utilise de nombreuses fonctions qui opèrent sur ces attributs (nom/taille/poids), alors l'utilisation de class pourrait être une bonne option.
Teifion, si vous utilisez des classes comme simple remplacement des tableaux, vous êtes loin d'être proche de la POO.L’essence de la POO est que les objets ont des connaissances et des responsabilités, peuvent réellement faire des choses et coopérer avec d’autres classes.Vos objets ont uniquement des connaissances et ne peuvent rien faire d'autre que d'exister sans rien faire, mais ils semblent être de bons candidats pour les fournisseurs de persistance (objets qui savent comment se stocker/récupérer dans/depuis la base de données).
Ne vous inquiétez pas non plus des performances.Les objets en PHP sont rapides et légers et les performances en général sont bien surfaites.Il est moins coûteux de gagner du temps en tant que programmeur en utilisant la bonne approche que de gagner des microsecondes dans votre programme avec un morceau de code obscur et difficile à déboguer et à corriger.
La plupart des tests qui chronométrent les tableaux par rapport aux classes testent uniquement leur instanciation.Une fois que vous commencez réellement à faire quelque chose avec eux.
J'étais un "puriste" qui n'utilisait que des tableaux parce que les performances étaient tellement meilleures.J'ai écrit le code suivant pour me justifier des tracas supplémentaires liés à la non-utilisation des classes (même si elles sont plus faciles pour le programmeur)
Disons simplement que j'ai été TRÈS surpris des résultats !
<?php
$rx = "";
$rt = "";
$rf = "";
$ta = 0; // total array time
$tc = 0; // total class time
// flip these to test different attributes
$test_globals = true;
$test_functions = true;
$test_assignments = true;
$test_reads = true;
// define class
class TestObject
{
public $a;
public $b;
public $c;
public $d;
public $e;
public $f;
public function __construct($a,$b,$c,$d,$e,$f)
{
$this->a = $a;
$this->b = $b;
$this->c = $c;
$this->d = $d;
$this->e = $e;
$this->f = $f;
}
public function setAtoB()
{
$this->a = $this->b;
}
}
// begin test
echo "<br>test reads: " . $test_reads;
echo "<br>test assignments: " . $test_assignments;
echo "<br>test globals: " . $test_globals;
echo "<br>test functions: " . $test_functions;
echo "<br>";
for ($z=0;$z<10;$z++)
{
$starta = microtime(true);
for ($x=0;$x<100000;$x++)
{
$xr = getArray('aaa','bbb','ccccccccc','ddddddddd','eeeeeeee','fffffffffff');
if ($test_assignments)
{
$xr['e'] = "e";
$xr['c'] = "sea biscut";
}
if ($test_reads)
{
$rt = $x['b'];
$rx = $x['f'];
}
if ($test_functions) { setArrAtoB($xr); }
if ($test_globals) { $rf = glb_arr(); }
}
$ta = $ta + (microtime(true)-$starta);
echo "<br/>Array time = " . (microtime(true)-$starta) . "\n\n";
$startc = microtime(true);
for ($x=0;$x<100000;$x++)
{
$xo = new TestObject('aaa','bbb','ccccccccc','ddddddddd','eeeeeeee','fffffffffff');
if ($test_assignments)
{
$xo->e = "e";
$xo->c = "sea biscut";
}
if ($test_reads)
{
$rt = $xo->b;
$rx = $xo->f;
}
if ($test_functions) { $xo->setAtoB(); }
if ($test_globals) { $xf = glb_cls(); }
}
$tc = $tc + (microtime(true)-$startc);
echo "<br>Class time = " . (microtime(true)-$startc) . "\n\n";
echo "<br>";
echo "<br>Total Array time (so far) = " . $ta . "(100,000 iterations) \n\n";
echo "<br>Total Class time (so far) = " . $tc . "(100,000 iterations) \n\n";
echo "<br>";
}
echo "TOTAL TIMES:";
echo "<br>";
echo "<br>Total Array time = " . $ta . "(1,000,000 iterations) \n\n";
echo "<br>Total Class time = " . $tc . "(1,000,000 iterations)\n\n";
// test functions
function getArray($a,$b,$c,$d,$e,$f)
{
$arr = array();
$arr['a'] = $a;
$arr['b'] = $b;
$arr['c'] = $c;
$arr['d'] = $d;
$arr['d'] = $e;
$arr['d'] = $f;
return($arr);
}
//-------------------------------------
function setArrAtoB($r)
{
$r['a'] = $r['b'];
}
//-------------------------------------
function glb_cls()
{
global $xo;
$xo->d = "ddxxdd";
return ($xo->f);
}
//-------------------------------------
function glb_arr()
{
global $xr;
$xr['d'] = "ddxxdd";
return ($xr['f']);
}
//-------------------------------------
?>
le test lit :1 affectations de test:1 test global:1 Fonctions de test:1
Temps de tableau = 1,58905816078 Temps de classe = 1,1198010446 Temps total du tableau (jusqu'à présent) = 1,58903813362 (100 000 itérations) Temps de classe total (jusqu'à présent) = 1,11979603767 (100 000 itérations)
Temps de tableau = 1,02581000328 Temps de classe = 1,22492313385 Temps total du tableau (jusqu'à présent) = 2,61484408379 (100 000 itérations) Temps de classe total (jusqu'à présent) = 2,34471416473 (100 000 itérations)
Temps de tableau = 1,29942297935 Temps de classe = 1,18844485283 Temps de tableau total (jusqu'à présent) = 3,91425895691 (100 000 itérations) Temps de classe total (jusqu'à présent) = 3,5331492424 (100 000 itérations)
Temps de tableau = 1,28776097298 Temps de classe = 1,02383089066 Temps total du tableau (jusqu'à présent) = 5.2020149231 (100 000 itérations) Temps de classe total (jusqu'à présent) = 4,55697512627 (100 000 itérations)
Temps de tableau = 1,31235599518 Temps de classe = 1,38880181313 Temps total du tableau (jusqu'à présent) = 6,51436591148 (100 000 itérations) Temps de classe total (jusqu'à présent) = 5,94577097893 (100 000 itérations)
Temps de tableau = 1,3007349968 Temps de classe = 1,07644081116 Temps de tableau total (jusqu'à présent) = 7,81509685516 (100 000 itérations) Temps de classe total (jusqu'à présent) = 7,02220678329 (100 000 itérations)
Temps de tableau = 1,12752890587 Temps de classe = 1,07106018066 Temps total du tableau (jusqu'à présent) = 8,94262075424 (100 000 itérations) Temps de classe total (jusqu'à présent) = 8,09326195717 (100 000 itérations)
Temps de tableau = 1,08890199661 Temps de classe = 1,09139609337 Temps de tableau total (jusqu'à présent) = 10,0315177441 (100 000 itérations) Temps de classe total (jusqu'à présent) = 9,18465089798 (100 000 itérations)
Temps de tableau = 1,6172170639 Temps de classe = 1,14714384079 Temps total du tableau (jusqu'à présent) = 11,6487307549 (100 000 itérations) Temps de classe total (jusqu'à présent) = 10,3317887783 (100 000 itérations)
Temps de tableau = 1,53738498688 Temps de classe = 1,28127002716 Temps total du tableau (jusqu'à présent) = 13,1861097813 (100 000 itérations) Temps de classe total (jusqu'à présent) = 11,6130547523 (100 000 itérations)
TEMPS TOTAL :Temps total du tableau = 13,1861097813 (1 000 000 itérations) Temps de classe total = 11,6130547523 (1 000 000 itérations)
Donc, dans tous les cas, la différence est assez négligeable.J'ai été très surpris de constater qu'une fois que vous commencez à accéder aux choses à l'échelle mondiale, les cours deviennent en réalité un peu plus rapides.
Mais ne me faites pas confiance, gérez-le vous-même.Personnellement, je me sens désormais totalement libre de toute culpabilité quant à l'utilisation de classes dans mes applications hautes performances.:D
@Richard Varno
J'ai exécuté votre code exact (après avoir corrigé les petits bugs) et j'ai obtenu des résultats très différents de ceux de vous.Les cours se déroulaient beaucoup sur mon installation PHP 5.3.17.
Temps de tableau = 0,69054913520813 Temps de classe = 1,1762700080872
Temps total du tableau (jusqu'à présent) = 0,69054508209229 (100 000 itérations) Temps total de classe (jusqu'à présent) = 1,1762590408325 (100 000 itérations)
Temps de tableau = 0,99001502990723 Temps de classe = 1,22034907341
Temps total du tableau (jusqu'à présent) = 1,6805560588837 (100 000 itérations) Temps de classe total (jusqu'à présent) = 2,3966031074524 (100 000 itérations)
Temps de tableau = 0,99191808700562 Temps de classe = 1,2245700359344
Temps total du tableau (jusqu'à présent) = 2,6724660396576 (100 000 itérations) Temps de classe total (jusqu'à présent) = 3,6211669445038 (100 000 itérations)
Temps de tableau = 0,9890251159668 Temps de classe = 1,2246470451355
Temps total du tableau (jusqu'à présent) = 3,661484003067 (100 000 itérations) Temps de classe total (jusqu'à présent) = 4,8458080291748 (100 000 itérations)
Temps de tableau = 0,99573588371277 Temps de classe = 1,1242771148682
Temps total du tableau (jusqu'à présent) = 4,6572148799896 (100 000 itérations) Temps de classe total (jusqu'à présent) = 5,9700801372528 (100 000 itérations)
Temps de tableau = 0,88518786430359 Temps de classe = 1,1427340507507
Temps total du tableau (jusqu'à présent) = 5,5423986911774 (100 000 itérations) Temps de classe total (jusqu'à présent) = 7,1128082275391 (100 000 itérations)
Temps de tableau = 0,87605404853821 Temps de classe = 0,95899105072021
Temps total du tableau (jusqu'à présent) = 6,4184486865997 (100 000 itérations) Temps de classe total (jusqu'à présent) = 8,0717933177948 (100 000 itérations)
Temps de tableau = 0,73414516448975 Temps de classe = 1,0223190784454
Temps total du tableau (jusqu'à présent) = 7,1525888442993 (100 000 itérations) Temps de classe total (jusqu'à présent) = 9,094103363342 (100 000 itérations)
Temps de tableau = 0,95230412483215 Temps de classe = 1,059828042984
Temps total du tableau (jusqu'à présent) = 8,1048839092255 (100 000 itérations) Temps de classe total (jusqu'à présent) = 10,153927326202 (100 000 itérations)
Temps de tableau = 0,75814390182495 Temps de classe = 0,84455919265747
Temps total du tableau (jusqu'à présent) = 8,8630249500275 (100 000 itérations) Temps de classe total (jusqu'à présent) = 10,998482465744 (100 000 itérations) Temps total:
Temps total du tableau = 8,8630249500275 (1 000 000 itérations) Temps de classe total = 10,998482465744 (1 000 000 itérations)
