Classi vs 2D array
https://stackoverflow.com/questions/24130
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Che è meglio usare in PHP, una matrice 2D o una classe?Ho incluso un esempio di quello che intendo con questo.
// 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;
Supponendo che qualcuno non esce e mostra che le classi sono troppo lento, sembra vittorie di classe.
Non ho idea di quale risposta mi deve accettare per ho solo con voto positivo di tutti.
E ora ho scritto due quasi identiche pagine, utilizzando la matrice 2D (scritto prima di questa domanda è stato pubblicato) e ora con una classe e devo dire che la classe produce molto più bello di codice.Non ho idea di quanto sovraccarico sta per essere generato, ma dubito che sarà in grado di competere per il miglioramento dello stesso codice.
Grazie per aver contribuito a fare di me un programmatore migliore.
Soluzione
La "classe" che hai costruito sopra è ciò che la maggior parte delle persone sarebbe utilizzare un struct in altre lingue.Io non sono sicuro di quello che le implicazioni in termini di prestazioni sono in PHP, anche se ho il sospetto istanziare degli oggetti è probabilmente più costoso qui, anche se solo da un po'.
Detto questo, se il costo è relativamente basso, È un po ' più facile per gestire gli oggetti, a mio parere.
Sto solo dicendo che il seguente sulla base del titolo e la tua domanda, ma:Tenete a mente che le classi di fornire il vantaggio di metodi e di controllo di accesso, come pure.Quindi, se si vuole assicurare che la gente non modifica i pesi per i numeri negativi, si potrebbe fare la weight settore privato e di fornire alcuni metodi supplementari, come getWeight() e setWeight().All'interno setWeight(), si potrebbe fare qualche controllo del valore, in questo modo:
public function setWeight($weight)
{
if($weight >= 0)
{
$this->weight = $weight;
}
else
{
// Handle this scenario however you like
}
}
Altri suggerimenti
Dipende esattamente cosa si intende per "meglio".Mi piacerebbe andare per il object oriented modo (utilizzando le classi) perché la trovo rende più pulito il codice (almeno a mio parere).Tuttavia, io non sono sicuro di quale sia la velocità di sanzioni potrebbe essere per l'opzione.
In genere io seguo questa regola:
1) la Rendono una classe se più parti dell'applicazione utilizzare la struttura dati.
2) la Rendono una matrice 2D se lo si usa per una rapida elaborazione dei dati in una parte della vostra applicazione.
È la velocità che penso, soprattutto, per qualcosa di più complesso di quello che ho qui avrei probabilmente andare con le classi, ma la domanda è, qual è il costo di una classe?
Questa sembrerebbe essere la prematura di ottimizzazione.L'applicazione non è andando a prendere il mondo reale calo di prestazioni in entrambi i modi, ma l'utilizzo di una classe consente di utilizzare i metodi getter e setter ed è in genere sta per essere meglio per incapsulamento del codice e il riutilizzo del codice.
Con le matrici sei incorrere in un costo in più per la lettura e la gestione di codice, non è possibile unit test il codice come facilmente e con una buona struttura di classe di altri sviluppatori dovrebbero trovare più facile capire se hanno bisogno di farlo.
E quando poi si devono aggiungere altri metodi per manipolare questi non hanno un'architettura di estendere.
La classe non è una vera classe in OO termini - il suo solo stata costruita per prendere lo spazio delle variabili di istanza.
Che ha detto - c'probabilmente non è tanto il problema con la velocità - il suo solo uno stile, cosa che nel tuo esempio.
L'interessante bit - è che se si contsrtucted l'oggetto per essere una vera e propria "persona", la categoria e thinkng su altri attributi e le azioni che si possono volere della persona di classe, allora si sarebbe accorto non solo una performance in stile - scrittura del codice, ma anche le prestazioni di velocità.
Se il codice utilizza un sacco di funzioni che operano su tali attributi (nome/altezza/peso), quindi usando la classe potrebbe essere una buona opzione.
Teifion, se si utilizzano le classi come una mera sostituzione per le matrici, si sono in nessun posto vicino OOP.L'essenza della OOP è che gli oggetti hanno la conoscenza e responsabilità, può effettivamente fare le cose e di cooperare con le altre classi.Gli oggetti hanno una conoscenza solo e non può fare altro che guardare esistono, tuttavia, sembrano essere buoni candidati per la persistenza di fornitori di oggetti che sapete come salvare/recuperare se stessi nel database).
Non preoccuparti di prestazioni, troppo.Oggetti in PHP sono veloci e leggeri e le prestazioni in generale è molto sopravvalutato.E ' più conveniente per salvare il vostro tempo come un programmatore che utilizza l'approccio giusto che per salvare microsecondi nel programma con qualche oscuro, difficile eseguire il debug e correggere pezzo di codice.
La maggior parte dei test che tempo matrici vs solo le classi di test istanze di loro.Una volta che effettivamente iniziare a fare qualcosa con loro.
Io sono una "purista" che ha usato solo le matrici perché la performance è stata molto meglio.Ho scritto il seguente codice per giustificare a me stesso per giustificare la seccatura di non usare le classi (anche se sono più facili da programmatore)
Diciamo che sono stato MOLTO sorpreso per i risultati!
<?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']);
}
//-------------------------------------
?>
il test si legge:1 prova assegnazioni:1 prova globals:1 funzioni di test:1
Array tempo = 1.58905816078 Il tempo di classe = 1.11980104446 Matrice totale tempo (finora) = 1.58903813362(100.000 iterazioni) Totale tempo di Classe (finora) = 1.11979603767(100.000 iterazioni)
Array tempo = 1.02581000328 Il tempo di classe = 1.22492313385 Matrice totale tempo (finora) = 2.61484408379(100.000 iterazioni) Totale tempo di Classe (finora) = 2.34471416473(100.000 iterazioni)
Array tempo = 1.29942297935 Il tempo di classe = 1.18844485283 Matrice totale tempo (finora) = 3.91425895691(100.000 iterazioni) Totale tempo di Classe (finora) = 3.5331492424(100.000 iterazioni)
Array tempo = 1.28776097298 Il tempo di classe = 1.02383089066 Matrice totale tempo (finora) = 5.2020149231(100.000 iterazioni) Totale tempo di Classe (finora) = 4.55697512627(100.000 iterazioni)
Array tempo = 1.31235599518 Il tempo di classe = 1.38880181313 Matrice totale tempo (finora) = 6.51436591148(100.000 iterazioni) Totale tempo di Classe (finora) = 5.94577097893(100.000 iterazioni)
Array tempo = 1.3007349968 Il tempo di classe = 1.07644081116 Matrice totale tempo (finora) = 7.81509685516(100.000 iterazioni) Totale tempo di Classe (finora) = 7.02220678329(100.000 iterazioni)
Array tempo = 1.12752890587 Il tempo di classe = 1.07106018066 Matrice totale tempo (finora) = 8.94262075424(100.000 iterazioni) Totale tempo di Classe (finora) = 8.09326195717(100.000 iterazioni)
Array tempo = 1.08890199661 Il tempo di classe = 1.09139609337 Matrice totale tempo (finora) = 10.0315177441(100.000 iterazioni) Totale tempo di Classe (finora) = 9.18465089798(100.000 iterazioni)
Array tempo = 1.6172170639 Il tempo di classe = 1.14714384079 Matrice totale tempo (finora) = 11.6487307549(100.000 iterazioni) Totale tempo di Classe (finora) = 10.3317887783(100.000 iterazioni)
Array tempo = 1.53738498688 Il tempo di classe = 1.28127002716 Matrice totale tempo (finora) = 13.1861097813(100.000 iterazioni) Totale tempo di Classe (finora) = 11.6130547523(100.000 iterazioni)
IL TOTALE DELLE VOLTE CHE:Matrice totale tempo = 13.1861097813(1.000.000 di iterazioni) Totale tempo di Classe = 11.6130547523(1.000.000 di iterazioni)
Così, in entrambi i casi la differenza è abbastanza trascurabile.Ero molto suprized di trovare che una volta che si avvia l'accesso a cose a livello globale, le classi effettivamente diventare un po ' più veloce.
Ma non fidarti di me, correre per la tua auto.Io personalmente ora si sentono completamente privo di sensi di colpa sull'utilizzo di classi nel mio applicazioni ad alte prestazioni.:D
@Richard Varno
Ho Eseguito il codice esatto (dopo aver risolto il bug), ed ho ottenuto molto diversi risultati di te.Classi di corse molto sulla mia PHP 5.3.17 installare.
Array tempo = 0.69054913520813 Il tempo di classe = 1.1762700080872
Matrice totale tempo (finora) = 0.69054508209229(100.000 iterazioni) Totale tempo di Classe (finora) = 1.1762590408325(100.000 iterazioni)
Array tempo = 0.99001502990723 Il tempo di classe = 1.22034907341
Matrice totale tempo (finora) = 1.6805560588837(100.000 iterazioni) Totale tempo di Classe (finora) = 2.3966031074524(100.000 iterazioni)
Array tempo = 0.99191808700562 Il tempo di classe = 1.2245700359344
Matrice totale tempo (finora) = 2.6724660396576(100.000 iterazioni) Totale tempo di Classe (finora) = 3.6211669445038(100.000 iterazioni)
Array tempo = 0.9890251159668 Il tempo di classe = 1.2246470451355
Matrice totale tempo (finora) = 3.661484003067(100.000 iterazioni) Totale tempo di Classe (finora) = 4.8458080291748(100.000 iterazioni)
Array tempo = 0.99573588371277 Il tempo di classe = 1.1242771148682
Matrice totale tempo (finora) = 4.6572148799896(100.000 iterazioni) Totale tempo di Classe (finora) = 5.9700801372528(100.000 iterazioni)
Array tempo = 0.88518786430359 Il tempo di classe = 1.1427340507507
Matrice totale tempo (finora) = 5.5423986911774(100.000 iterazioni) Totale tempo di Classe (finora) = 7.1128082275391(100.000 iterazioni)
Array tempo = 0.87605404853821 Il tempo di classe = 0.95899105072021
Matrice totale tempo (finora) = 6.4184486865997(100.000 iterazioni) Totale tempo di Classe (finora) = 8.0717933177948(100.000 iterazioni)
Array tempo = 0.73414516448975 Il tempo di classe = 1.0223190784454
Matrice totale tempo (finora) = 7.1525888442993(100.000 iterazioni) Totale tempo di Classe (finora) = 9.0941033363342(100.000 iterazioni)
Array tempo = 0.95230412483215 Il tempo di classe = 1.059828042984
Matrice totale tempo (finora) = 8.1048839092255(100.000 iterazioni) Totale tempo di Classe (finora) = 10.153927326202(100.000 iterazioni)
Array tempo = 0.75814390182495 Il tempo di classe = 0.84455919265747
Matrice totale tempo (finora) = 8.8630249500275(100.000 iterazioni) Totale tempo di Classe (finora) = 10.998482465744(100.000 iterazioni) IL TOTALE DELLE VOLTE CHE:
Matrice totale tempo = 8.8630249500275(1.000.000 di iterazioni) Totale tempo di Classe = 10.998482465744(1.000.000 di iterazioni)
