versatile collections
New Major Release
Un paquete de colección que se puede ampliar para implementar cosas como un contenedor de inyección de dependencia, objetos RecordSet para alojar registros de bases de datos, una bolsa de cookies http o, técnicamente, cualquier colección de elementos que se puedan recorrer en bucle y a cuyos elementos se pueda acceder mediante una matriz. -sintaxis de acceso o sintaxis de propiedad de objeto.
Puede:
Este paquete proporciona una tipificación estricta opcional de los elementos de la colección y se esfuerza por lograr una cobertura de prueba unitaria del 100 %.
A través del compositor: (Requiere PHP 7.4+ o PHP 8.0+).
Cambie a la rama 3.X para leer la documentación de la versión 3.X.
Cambie a la rama 4.X para leer la documentación de la versión 4.X.
Cambie a la rama 5.x para leer la documentación de la versión 5.x.
Cambie a la rama master para leer la documentación de la última versión.
composer require rotexsoft/versatile-collections
Si simplemente busca almacenar elementos del mismo tipo o de diferentes tipos en una colección, puede usar simplemente la clase GenericCollection de esta manera:
<?php
use VersatileCollections GenericCollection ;
// items to be stored in your collection
$ item1 = [ ' yabadoo ' ]; // an array
$ item2 = function (){ echo ' Hello World! ' ; }; // a callable
$ item3 = 777.888 ; // a float
$ item4 = 777 ; // an int
$ item5 = new stdClass (); // an object
$ item6 = new ArrayObject ([]); // another object
$ item7 = tmpfile (); // a resource
$ item8 = true ; // a boolean
$ item9 = " true " ; // a string
// Technique 1: pass the items to the constructor of the collection class
$ collection = new VersatileCollections GenericCollection (
$ item1 , $ item2 , $ item3 , $ item4 , $ item5 , $ item6 , $ item7 , $ item8 , $ item9
);
// Technique 2: pass the items in an array using argument unpacking
// to the constructor of the collection class
$ collection = new GenericCollection (
...[ $ item1 , $ item2 , $ item3 , $ item4 , $ item5 , $ item6 , $ item7 , $ item8 , $ item9 ]
);
// Technique 3: pass the items in an iterable (such as an array) to the static makeNew helper method
// available in all collection classes
$ collection = GenericCollection:: makeNew (
[ $ item1 , $ item2 , $ item3 , $ item4 , $ item5 , $ item6 , $ item7 , $ item8 , $ item9 ]
);
// Technique 4: create an empty collection object and subsequently add each
// item to the collection via array assignment syntax or object
// property assignment syntax or using the appendItem($item),
// prependItem($item, $key=null), push($item) or put($key, $value)
// methods
$ collection = new GenericCollection (); // empty collection
// OR
$ collection = GenericCollection:: makeNew (); // empty collection
$ collection [] = $ item1 ; // array assignment syntax without key
// the item is automatically assigned
// the next available integer key. In
// this case 0
$ collection [] = $ item2 ; // array assignment syntax without key
// the next available integer key in this
// case is 1
$ collection [ ' some_key ' ] = $ item3 ; // array assignment syntax with specified key `some_key`
$ collection -> some_key = $ item4 ; // object property assignment syntax with specified property
// `some_key`. This will update $collection['some_key']
// changing its value from $item3 to $item4
$ collection -> appendItem ( $ item3 ) // same effect as:
-> appendItem ( $ item5 ); // $collection[] = $item3;
// $collection[] = $item5;
// Adds an item to the end of the collection
// You can chain the method calls
$ collection -> prependItem ( $ item6 , ' new_key ' ); // adds an item with the optional
// specified key to the front of
// collection.
// You can chain the method calls
$ collection -> push ( $ item7 ); // same effect as:
// $collection[] = $item7;
// Adds an item to the end of the collection
// You can chain the method calls
$ collection -> put ( ' eight_item ' , $ item8 ) // same effect as:
-> put ( ' ninth_item ' , $ item9 ); // $collection['eight_item'] = $item8;
// $collection['ninth_item'] = $item9;
// Adds an item with the specified key to
// the collection. If the specified key
// already exists in the collection the
// item previously associated with the
// key is overwritten with the new item.
// You can chain the method callsTambién puede hacer que cualquier clase en su aplicación se comporte exactamente como VersatileCollectionsGenericCollection implementando VersatileCollectionsCollectionInterface y usando VersatileCollectionsCollectionInterfaceImplementationTrait en dichas clases.
Si desea aplicar una escritura estricta, en este paquete se proporcionan las siguientes clases de colección:
Para implementar una colección personalizada que solo contenga objetos que sean instancias de una clase específica (por ejemplo PDO ), su clase de colección personalizada debe cumplir con los siguientes requisitos:
Su clase de colección personalizada debe implementar VersatileCollectionsStrictlyTypedCollectionInterface que actualmente contiene los siguientes métodos:
$item es del tipo esperado o falso en caso contrarioSu clase de colección personalizada debe usar VersatileCollectionsStrictlyTypedCollectionInterfaceImplementationTrait (que contiene la implementación de los métodos en VersatileCollectionsStrictlyTypedCollectionInterface ). Si elige no utilizar VersatileCollectionsStrictlyTypedCollectionInterfaceImplementationTrait , tendrá que implementar todos los métodos especificados en VersatileCollectionsStrictlyTypedCollectionInterface y asegurarse de llamar al método checkType(mixed $item) en cada método en el que agregue o modifique elementos. en la colección como offsetSet($key, $val) y lanza un Excepción de VersatileCollectionsExceptionsInvalidItemException cada vez que checkType(mixed $item) devuelve falso. Si usa VersatileCollectionsStrictlyTypedCollectionInterfaceImplementationTrait en su clase de colección personalizada pero agrega nuevos métodos que también agregan o modifican elementos en la colección, puede usar el método auxiliar isRightTypeOrThrowInvalidTypeException($item, $calling_functions_name) proporcionado en VersatileCollectionsStrictlyTypedCollectionInterfaceImplementationTrait para validar elementos (se lanzará automáticamente una excepción para usted si el elemento que está validando es del tipo incorrecto; consulte VersatileCollectionsStrictlyTypedCollectionInterfaceImplementationTrait::offsetSet($key, $val) para ver un ejemplo de cómo se debe utilizar este método auxiliar).
Opcionalmente, puedes anular StrictlyTypedCollectionInterfaceImplementationTrait::__construct(mixed ...$arr_objs) con un constructor con la misma firma pero con el tipo específico. Por ejemplo, __construct(PDO ...$pdo_objs) garantiza que solo se puedan inyectar instancias de PDO en el constructor mediante el desempaquetado de argumentos.
El siguiente ejemplo de código muestra cómo se puede implementar una clase de colección personalizada llamada PdoCollection , que solo almacena elementos que son instancias de PDO :
<?php
use VersatileCollections StrictlyTypedCollectionInterface ;
class PdoCollection implements StrictlyTypedCollectionInterface { //1. Implement interface
use VersatileCollections StrictlyTypedCollectionInterfaceImplementationTrait; //2. Use trait
public function __construct ( PDO ... $ pdo_objs ) { //3. Optionally override the constructor with a type
// specific one
$ this -> versatile_collections_items = $ pdo_objs ;
}
/**
*
* @return bool true if $item is of the expected type, else false
*
*/
public function checkType ( mixed $ item ): bool { //4. implement interface methods not implemented in trait above
return ( $ item instanceof PDO );
}
/**
*
* @return string|array a string or array of strings of type name(s)
* for items acceptable in instances of this
* collection class
*
*/
public function getTypes (): VersatileCollections StringsCollection { //4. implement interface methods not implemented in trait above
return new VersatileCollections StringsCollection ( PDO ::class);
}
}Puede declarar sus clases de colección con tipos personalizados como finales para que los usuarios de sus clases no puedan extenderlas y, por lo tanto, eludir la verificación de tipos que se aplica en el momento de la construcción y en el momento de agregar elementos.
NOTA: Si solo desea almacenar elementos que son instancias de una clase específica o sus subclases en una colección y no desea tener que crear una clase de colección personalizada para ese propósito, simplemente use SpecificObjectsCollection.
Glosario de métodos por categoría
Descripciones de métodos con ejemplos
Colecciones genéricas
Colecciones estrictamente tipificadas
Equivalencia de métodos de colección de Laravel
Envíe un problema o una solicitud de extracción si encuentra algún problema con la documentación.
