versatile collections
New Major Release
Ein Sammlungspaket, das erweitert werden kann, um Dinge wie einen Dependency-Injection-Container, RecordSet-Objekte zum Unterbringen von Datenbankdatensätzen, eine Tüte mit http-Cookies oder technisch gesehen jede Sammlung von Elementen zu implementieren, über die eine Schleife ausgeführt werden kann und auf deren Elemente jeweils mithilfe eines Arrays zugegriffen werden kann -access-Syntax oder Objekteigenschaftssyntax.
Du kannst:
Dieses Paket bietet eine optionale strikte Typisierung von Sammlungselementen und strebt eine 100 %ige Unit-Test-Abdeckung an.
Über Composer: (Erfordert PHP 7.4+ oder PHP 8.0+).
Wechseln Sie zum 3.X-Zweig, um die Dokumentation für die 3.X-Version zu lesen.
Wechseln Sie zum 4.X-Zweig, um die Dokumentation für die 4.X-Version zu lesen.
Wechseln Sie zum 5.x-Zweig, um die Dokumentation für die 5.x-Version zu lesen.
Wechseln Sie zum Hauptzweig, um die Dokumentation für die neueste Version zu lesen.
composer require rotexsoft/versatile-collections
Wenn Sie einfach Elemente des gleichen oder unterschiedlichen Typs in einer Sammlung speichern möchten, können Sie einfach die GenericCollection -Klasse wie folgt verwenden:
<?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 callsSie können auch dafür sorgen, dass sich jede Klasse in Ihrer Anwendung genau wie VersatileCollectionsGenericCollection verhält, indem Sie VersatileCollectionsCollectionInterface implementieren und VersatileCollectionsCollectionInterfaceImplementationTrait in solchen Klassen verwenden.
Wenn Sie eine strikte Typisierung erzwingen möchten, werden in diesem Paket die folgenden Collection-Klassen bereitgestellt:
Um eine benutzerdefinierte Sammlung zu implementieren, die nur Objekte enthält, die Instanzen einer bestimmten Klasse sind (z. B. PDO ), muss Ihre benutzerdefinierte Sammlungsklasse die folgenden Anforderungen erfüllen:
Ihre benutzerdefinierte Sammlungsklasse muss VersatileCollectionsStrictlyTypedCollectionInterface implementieren, das derzeit die folgenden Methoden enthält:
$item vom erwarteten Typ ist, andernfalls falseIhre benutzerdefinierte Sammlungsklasse sollte VersatileCollectionsStrictlyTypedCollectionInterfaceImplementationTrait verwenden (das die Implementierung der Methoden in VersatileCollectionsStrictlyTypedCollectionInterface enthält). Wenn Sie VersatileCollectionsStrictlyTypedCollectionInterfaceImplementationTrait nicht verwenden möchten, müssen Sie alle in VersatileCollectionsStrictlyTypedCollectionInterface angegebenen Methoden implementieren und sicherstellen, dass Sie die Methode checkType(mixed $item) in jeder Methode aufrufen, in der Sie Elemente hinzufügen oder Elemente ändern in der Sammlung wie offsetSet($key, $val) und throw an VersatileCollectionsExceptionsInvalidItemException -Ausnahme, wenn checkType(mixed $item) false zurückgibt. Wenn Sie VersatileCollectionsStrictlyTypedCollectionInterfaceImplementationTrait in Ihrer benutzerdefinierten Sammlungsklasse verwenden, aber neue Methoden hinzufügen, die auch Elemente zur Sammlung hinzufügen oder Elemente in der Sammlung ändern, können Sie die in VersatileCollectionsStrictlyTypedCollectionInterfaceImplementationTrait bereitgestellte Hilfsmethode isRightTypeOrThrowInvalidTypeException($item, $calling_functions_name) verwenden, um Elemente zu validieren (Es wird automatisch eine Ausnahme für Sie ausgelöst wenn das Element, das Sie validieren, vom falschen Typ ist; siehe VersatileCollectionsStrictlyTypedCollectionInterfaceImplementationTrait::offsetSet($key, $val) für ein Beispiel, wie diese Hilfsmethode verwendet werden sollte.
Sie können StrictlyTypedCollectionInterfaceImplementationTrait::__construct(mixed ...$arr_objs) optional mit einem Konstruktor mit derselben Signatur, aber mit dem spezifischen Typ überschreiben. Beispielsweise stellt __construct(PDO ...$pdo_objs) sicher, dass nur Instanzen von PDO über das Entpacken von Argumenten in den Konstruktor eingefügt werden können.
Das folgende Codebeispiel zeigt, wie eine benutzerdefinierte Sammlungsklasse namens PdoCollection implementiert werden kann, die nur Elemente speichert, die Instanzen von PDO sind:
<?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);
}
}Sie können Ihre benutzerdefinierten typisierten Sammlungsklassen als endgültig deklarieren, sodass Benutzer Ihrer Klassen sie nicht erweitern können und dadurch die Typprüfung umgehen, die zum Zeitpunkt der Erstellung und des Hinzufügens von Elementen erzwungen wird.
HINWEIS: Wenn Sie in einer Sammlung nur Elemente speichern möchten, die nur Instanzen einer bestimmten Klasse oder ihrer Unterklassen sind, und zu diesem Zweck keine benutzerdefinierte Sammlungsklasse erstellen möchten, verwenden Sie einfach SpecificObjectsCollection
Methodenglossar nach Kategorie
Methodenbeschreibungen mit Beispielen
Allgemeine Sammlungen
Streng typisierte Sammlungen
Äquivalenz der Laravel-Erfassungsmethoden
Bitte reichen Sie einen Issue- oder Pull-Request ein, wenn Sie Probleme mit der Dokumentation feststellen.
