Differenza tra ArrayIterator, ArrayObject e Array in PHP

Question

Qualcuno può spiegare chiaramente le differenze fondamentali tra ArrayIterator, ArrayObject e Array in PHP in termini di funzionalità e funzionamento? Grazie!

Answer 1

può essere che si trova la risposta qui:

• The ArrayIterator class

Questo iteratore permette di disinserire e modificare i valori e le chiavi, mentre iterazione di array e gli oggetti.

Quando si desidera iterare gli stessi tempi di matrice multipla è necessario creare un'istanza ArrayObject e lasciarlo creare istanze ArrayIterator che fanno riferimento ad esso sia utilizzando foreach o chiamando il suo metodo getIterator() manualmente.

Leggi anche:

• The ArrayObject class
• Arrays

Answer 2

Array è un tipo php nativo. È possibile crearne uno utilizzando il linguaggio php costrutto array(), o come di PHP 5.4 in poi []

ArrayObject è un object che funzionano esattamente come gli array. Questi possono essere creati usando la parola chiave new

ArrayIterator è come ArrayObject ma può iterare su se stesso. Inoltre creata usando new

---

Confrontando Array vs (ArrayObject/ArrayIterator)

Entrambi possono essere utilizzati utilizzando la sintassi di matrice del php, per es.

$array[] = 'foo'; 
$object[] = 'foo'; 
// adds new element with the expected numeric key 

$array['bar'] = 'foo'; 
$object['bar'] = 'foo'; 
// adds new element with the key "bar" 

foreach($array as $value); 
foreach($object as $value); 
// iterating over the elements 

Tuttavia, essi sono oggetti ancora vs array, quindi si dovrebbe notare le differenze di

is_array($array); // true 
is_array($object); // false 

is_object($array); // false 
is_object($object); // true 

La maggior parte delle funzioni PHP di matrice si aspettano le matrici, in modo da utilizzare gli oggetti ci sarebbe buttare errori. Ci sono molte di queste funzioni. Per es.

sort($array); // works as expected 
sort($object); // Warning: sort() expects parameter 1 to be array, object given in ...... 

Infine, gli oggetti possono fare quello che ci si aspetta da un oggetto stdClass, vale a dire l'accesso a proprietà pubbliche utilizzando la sintassi dell'oggetto

$object->foo = 'bar'; // works 
$array->foo = 'bar'; // Warning: Attempt to assign property of non-object in .... 

Array (essendo il tipo nativo) sono molto più veloce di oggetti.D'altra parte, i ArrayObject & ArrayIterator classi sono certi metodi definiti che è possibile utilizzare, mentre non v'è nulla di simile per gli array

---

Confrontando ArrayObject vs ArrayIterator

La principale differenza tra questi 2 è nei metodi che le classi hanno.

L'interfaccia ArrayIterator implementa l'interfaccia Iterator che fornisce metodi relativi all'iterazione/loop sugli elementi. ArrayObject ha un metodo chiamato exchangeArray che scambia la sua matrice interna con un'altra. Implementare una cosa simile in ArrayIterator significherebbe creare un nuovo oggetto o fare un ciclo attraverso i tasti & unset inserendoli tutti uno ad uno & quindi impostando gli elementi dal nuovo array uno per uno.

Avanti, dal momento che il ArrayObject non può essere iterato, quando lo si utilizza in foreach crea un oggetto ArrayIterator internamente (lo stesso array). Ciò significa che php crea una copia dei dati originali & ora ci sono 2 oggetti con lo stesso contenuto. Ciò si rivelerà inefficiente per i grandi array. Tuttavia, è possibile specificare quale classe utilizzare per l'iteratore, in modo da poter avere iteratori personalizzati nel codice.

---

Spero che questo sia utile. Le modifiche a questa risposta sono benvenute.

Answer 3

ArrayObject e array sono in qualche modo uguali. Semplicemente una collezione di oggetti (o tipi nativi). Hanno metodi diversi che puoi chiamare, ma si riducono per lo più alla stessa cosa.

Tuttavia, un Iterator è qualcosa di completamente diverso. Il pattern di progettazione iteratore è un modo per proteggere l'array (rendendolo leggibile solo). Prendiamo il prossimo esempio:

Hai una classe che ha una matrice. È possibile aggiungere elementi a tale array utilizzando addSomethingToMyArray. Si noti, tuttavia, che facciamo qualcosa sull'elemento prima di aggiungerlo effettivamente alla matrice. Questo potrebbe essere qualsiasi cosa, ma lascia che per un momento si comporti come se fosse molto importante che questo metodo venga attivato per OGNI elemento che vogliamo aggiungere all'array.

class A 
{ 
    private $myArray; 
    public function returnMyArray() 
    { 
     return $this->myArray; 
    } 

    public function addSomethingToMyArray($item) 
    { 
     $this->doSomethingToItem($item); 
     array_push($item); 
    } 
} 

Il problema con questo, è che si passa la matrice per riferimento qui. Ciò significa che le classi che effettivamente utilizzano returnMyArray ottengono il vero oggetto myArray. Ciò significa che le classi diverse da A possono aggiungere elementi a quell'array e quindi anche modificare l'array all'interno di A senza dover utilizzare addSOmethingToMyArray. Ma dovevamo fare SOmethingToItem, ricordi? Questo è un esempio di una classe che non ha il controllo del proprio stato interiore.

La soluzione a questo è un iteratore. Invece di passare l'array, passiamo l'array a un nuovo oggetto, che può solo leggere le cose dall'array. Il più semplice Iterator di sempre è qualcosa del genere:

<?php 

class MyIterator{ 

    private $array; 
    private $index; 

    public function __construct($array) 
    { 
     $this->array = $array; 
    } 

    public function hasNext() 
    { 
     return count($this->array) > $this->index; 
    } 

    public function next() 
    { 
     $item = $this->array[ $this->index ]; 
     this->$index++; 

     return $item; 
    }  
} 

?>

Come si può vedere, non ho modo di aggiungere nuovi elementi alla matrice data, ma ho posibilities leggere la matrice in questo modo:

while($iterator->hasNext()) 
    $item = $iterator->next(); 

Ora c'è di nuovo, solo un modo per aggiungere elementi a myArray in A, vale a dire tramite il metodo addSomethingToArray. Ecco cos'è un Iterator, è un po 'una shell attorno agli array, per fornire qualcosa chiamato incapsulamento.

Answer 4

array è uno degli otto tipi primitivi in ​​PHP. Anche se viene fornito con molte funzioni di utilità incorporate, ma sono tutte procedurali.

Sia lo ArrayObject sia lo ArrayIterator ci consentono di creare array di cittadini di prima classe in un programma orientato agli oggetti (OOP).

Differenza tra ArrayObject e ArrayIterator è che, dal momento che ArrayIterator implementa SeekableIterator interfaccia, è possibile fare con $myArray->seek(10);ArrayIterator.

Answer 5

Un Iterator è un oggetto che consente a un programmatore di attraversare un contenitore, in particolare gli elenchi. Vari tipi di iteratori vengono spesso forniti tramite l'interfaccia di un contenitore.

Non c'è molta differenza tra ArrayObject e Array in quanto rappresentano le stesse cose anche se si utilizzano tipi di oggetto diversi.

ArrayIterator è un Iterator che scorre sopra Array-like oggetti, questo include tutti gli oggetti che implementano ArrayAcess e il Array tipo nativo. In realtà, quando si foreach su un array, PHP crea internamente ArrayIterator di fare la traslazione e trasformare il vostro codice a guardare come se digitato questo,

for($arrayIterator->rewind(); $arrayIterator->valid(); $arrayIterator- 
>next()) 
{ $key = $arrayIteartor->key(); 
    $value = $arrayIterator->current(); 
} 

Così si può vedere, ogni oggetto collezione ha un iteratore ad eccezione le tue collezioni definite di cui hai bisogno per definire i tuoi Iterators.