Diferença entre ArrayIterator, ArrayObject e Array em PHP

Alguém pode explicar claramente as diferenças fundamentais entre ArrayIterator , ArrayObject e Array em PHP em termos de funcionalidade e operação? Obrigado!

Array é um tipo php nativo. Você pode criar um usando a array() construção de idioma php array() ou a partir do php 5.4 em diante []

ArrayObject é um object que funciona exatamente como arrays. Estes podem ser criados usando new palavra-chave

ArrayIterator é como ArrayObject mas pode iterar sobre si mesmo. Também criado usando new


Comparando Array vs ( ArrayObject / ArrayIterator )

Ambos podem ser usados ​​usando a syntax da matriz do php, por exemplo,

 $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 

No entanto, eles ainda são objects vs arrays, então você notará as diferenças em

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

A maioria das funções de matriz de php esperam arrays, de modo que usar objects lançaria erros. Existem muitas dessas funções. Por exemplo,

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

Finalmente, os objects podem fazer o que você esperaria de um object stdClass , ou seja, acessar propriedades públicas usando a syntax do object

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

Arrays (sendo o tipo nativo) são muito mais rápidos do que os objects. Do outro lado, as ArrayObject & ArrayIterator possuem certos methods definidos que você pode usar, enquanto não há tal coisa para arrays


Comparando ArrayObject vs ArrayIterator

A principal diferença entre estes 2 é nos methods que as classs possuem.

O ArrayIterator implementa a interface Iterator que lhe dá methods relacionados à iteração / looping sobre os elementos. ArrayObject possui um método chamado exchangeArray que troca sua matriz interna com outra. Implementar uma coisa semelhante no ArrayIterator significaria criar um novo object ou fazer um loop pelas chaves e unset -las uma a uma e, em seguida, definir os elementos da nova matriz, um a um.

Em seguida, uma vez que ArrayObject não pode ser iterado, quando você o usa no foreach ele cria um object ArrayIterator internamente (o mesmo que arrays). Isso significa que o php cria uma cópia dos dados originais e agora existem 2 objects com o mesmo conteúdo. Isso irá revelar-se ineficaz para matrizes grandes. No entanto, você pode especificar qual class usar para o iterador, para que você possa ter iteradores personalizados no seu código.


Espero que isso seja útil. As edições para esta resposta são bem-vindas.

ArrayObject e array são um tanto parecidos. Simplesmente uma coleção de objects (ou tipos nativos). Eles têm alguns methods diferentes que você pode chamar, mas principalmente se resume ao mesmo.

No entanto, um Iterator é completamente diferente. O padrão de design do iterador é uma maneira de proteger sua matriz (tornando-se apenas legível). Vamos dar o seguinte exemplo:

Você tem uma class que possui uma matriz. Você pode adicionar itens a essa matriz usando addSomethingToMyArray. Note, no entanto, que fazemos algo para o item antes de o adicionarmos à matriz. Isso pode ser qualquer coisa, mas deixa por um momento agir como se fosse muito importante que esse método seja triggersdo para CADA item que queremos adicionar à matriz.

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

O problema com isso é que você passa a matriz por referência aqui. Isso significa que as classs que realmente usam returnMyArray obtêm o object real myArray. Isso significa que classs diferentes de A podem adicionar coisas a essa matriz, e também alteram a matriz dentro de A sem ter que usar o addSOmethingToMyArray. Mas precisávamos fazer algo importante, lembre-se? Este é um exemplo de uma class que não controla seu próprio status interno.

A solução para isso é um iterador. Em vez de passar a matriz, passamos a matriz para um novo object, que só pode LER coisas da matriz. O Iterator mais simples já é algo assim:

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

?>

Como você pode ver, não tenho como adicionar novos itens à matriz dada, mas tenho possibilidades para ler a matriz como esta:

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

Agora, há novamente, apenas uma maneira de adicionar itens ao myArray em A, ou seja, através do método addSomethingToArray. Então, é isso que é um Iterator, é um pouco de shell em torno de arrays, para fornecer algo chamado encapsulamento.

Pode ser que você encontre sua resposta aqui:

  • A class ArrayIterator

Este iterador permite desativar e modificar valores e chaves durante a iteração em Arrays e objects.

Quando você quiser iterar sobre a mesma matriz várias vezes, você precisa instanciar ArrayObject e permitir que crie instâncias ArrayIterator que se referem a ela usando o foreach ou chamando seu método getIterator () manualmente.

Leia também:

  • A class ArrayObject
  • Arrays

array é um dos oito tipos primitivos em PHP. Embora possua muitas funções de utilidade embutidas, mas todas são processuais.

Tanto o ArrayObject quanto o ArrayIterator nos permitem fazer arrays de primeira class em um programa orientado a objects (OOP).

A diferença entre ArrayObject e ArrayIterator é que, uma vez que o ArrayIterator implementa a interface SeekableIterator , você pode fazer $myArray->seek(10); com ArrayIterator .

Um Iterator é um object que permite que um programador percorra um contêiner, particularmente listas. Vários tipos de iteradores são freqüentemente fornecidos através da interface de um recipiente.

Não há muita diferença entre ArrayObject e Array pois eles representam as mesmas coisas, embora usando diferentes tipos de object.

ArrayIterator é um Iterator que itera em objects Array-like , isto inclui todos os objects que implementam ArrayAcess e o tipo de Array nativo. Na verdade, quando você foreach uma matriz, o PHP cria internamente o ArrayIterator para fazer o percurso e transformar seu código para parecer como typescript isso,

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

Então, você pode ver, cada object de coleção tem um Iterator, exceto suas collections definidas, para as quais você precisa definir seus próprios Iterators.

    Intereting Posts