Cosa è meglio stdClass o array (oggetto) per memorizzare i dati correlati?

Question

Ho utilizzato gli array per archiviare i campi correlati per un lungo periodo. Se volevo avere campi utente connessi, ho usato:

$user = array(
    'id' => 27 
    'name' => 'Pepe' 
); 

Ma ultimamente, ho lavorato molto con gli oggetti, e mi piace di più per utilizzare $ user-> id, invece di $ user [' id '].

La mia domanda: Per raggiungere uno stile orientato agli oggetti, è possibile utilizzare stdClass:

$user = new stdClass(); 
$user->id = 27; 
$user->name = 'Pepe'; 

o la fusione tra una vasta gamma

$user = (object) array(
    'id' => 27 
, 'name' => 'Pepe' 
); 

è uno di loro migliore rispetto agli altri, in ordine di performance e stile, oppure puoi usare quello che vuoi indistintamente?

Grazie!

Aggiornamento: Sono d'accordo con tutti i commenti, questo non è OOP a tutti, è solo di avere i dati relativi raggruppati in una struttura. Il mio esempio $ utente non è il migliore, perché è un tipico esempio di utilizzo di classi con metodo, proprietà, blablabla ... Ho chiesto perché ho un sacco di strutture di configurazione, come "initTable", e voglio qualcosa del tipo:

$table => page => init => 1 
       => end => 25 
      sort => field => name 
       => order => asc 

e così via, e io voglio sapere che cosa è meglio per ottenere la pagina init:

$table->page->init **OR** $table['page']['init'] 

Answer 1

Basato su test di piccole dimensioni (http://phpfiddle.org/lite/code/cz0-hyf) Posso dire che l'uso di "new stdClass()" è circa 3 volte più lento di altre opzioni.

È strano, ma il casting di un array viene eseguito in modo molto efficiente rispetto a stdClass.

Ma questo test esegue solo il tempo di esecuzione. Non misura la memoria.

P.S. Ho usato phpFiddle solo per condividere il codice. Il test è stato fatto sul mio PC locale.

Answer 2

prova esaminare la questione, qui un test facendo ogni 1.000.000 volte ciascuno:

$start = microtime(true); 
for ($i=0;$i<1000000;$i++) { 
    $user = new stdClass(); 
    $user->id = 27; 
    $user->name = 'Pepe'; 
} 
$end = microtime(true); 
echo $end - $start; 

echo '<br><br>'; 

$start = microtime(true); 
for ($i=0;$i<1000000;$i++) { 
    $user = (object) array(
     'id' => 27, 
     'name' => 'Pepe' 
    ); 
} 
$end = microtime(true); 
echo $end - $start; 

segnalazioni

0.75109791755676 
0.51117610931396 

così - appearently, in questo caso particolare - colata da array è il modo più veloce per farlo. Beats stdClass con molte percentuali. Ma non lo conterei come regola generale o legge universale.

Answer 3

Non penso che spostare una matrice su un oggetto standard possa fare la differenza. Tranne che non è più possibile utilizzare la maggior parte delle funzioni array_*.
Non riesco a vedere alcun vantaggio utilizzando un oggetto dinamico su un array indicizzato.

In questo caso, vorrei creare una classe per ogni elemento e proprietà di cui avresti bisogno.

class User 
{ 
    protected $id; 
    protected $name; 

    public function __construct($id = null, $name = null) 
    { 
     $this->id = $id; 
     $this->name = $name; 
    } 

    public function getName() 
    { 
     return $this->name; 
    } 

    public function setName($name) 
    { 
     $this->name = $name; 
    } 
} 

Con un tale design, sai esattamente quale tipo di parametri hai.

$user = new User(21, 'Foo'); 
echo $user->getName(); // Foo 

$blank = new User(22); 
echo $blank->getName(); // NULL 

Nessun errore, nessun controllo.
Con una array o stdClass si avrebbe una cosa del genere

$user = array('id' => 21, 'name' => 'Foo'); 
echo $user['name']; // Foo 

$blank = array('id' => 22); 
echo $blank['name']; // NOTICE: Undefined offset 
echo isset($blank['name']) ? $blank['name'] : null; // NULL 

Per questo tipo di comportamento, avendo un oggetto solido in cui si conosce l'interfaccia è più facile da mantenere e da torcere.