Key Takeaways
- Collection classes in PHP are object-oriented replacements for traditional array data structures, providing a structured way to manage groups of objects and offering built-in methods for data manipulation.
- A basic collection class should expose methods for adding, retrieving, and deleting items, as well as methods to determine the size of the collection and whether a given key exists in the collection.
- Collection classes can enhance performance, particularly when dealing with large data sets, as they use lazy instantiation to create elements in the array only when needed, saving system resources.
- Collection classes can be particularly useful when working with databases in PHP, as they can manage large sets of data more efficiently and make code more readable and maintainable.
- Establishes a wrapper around a array of objects.
- Collections are mutable – new elements may be added and existing elements may be modified or removed.
- Sorting algorithms are unstable (which means the order for equal elements is undefined).
- Can use lazy instantiation to save system resources.
Problem with Arrays
Applications frequently have objects that contain a group of other objects, and this is a great place to make use of collections. For example, suppose we decide to create a book store system. Let’s say we’ve written a customer class which, among other things, holds a list of books that the customer would like to purchase:<?php
class Customer
{
public $items = array();
// ...
}
$customer = new Customer(1234);
foreach ($customer->items as $item) {
echo $item->name;
}
If the most obvious approach (using an array) were the best possible approach, I wouldn’t write this article. The above example has these problems:
- We’ve broken encapsulation – the array is exposed as a public member variable.
- There is ambiguity in indexing and how to traverse the array to find a specific item.
A Basic Collection Class
A collection class needs to expose methods that allow us to add, retrieve, and delete items, and it’s helpful to have a method that lets us know the size of the collection. So, a basic class would start like this:<?php
class Collection
{
private $items = array();
public function addItem($obj, $key = null) {
}
public function deleteItem($key) {
}
public function getItem($key) {
}
}
The $items
array provides a location in which to store the objects that are members of the collection. addItem()
lets us add a new object to the collection, deleteItem()
removes an object, and getItem()
returns an object.
With addItem()
, we add an object to the collection by putting it in the $items
array at a specified location specified by $key
(if no key is provided, we let PHP pick the next available index). If an attempt is made to add an object using a key that already exists, an exception should be thrown to prevent inadvertently overwriting existing information:
public function addItem($obj, $key = null) {
if ($key == null) {
$this->items[] = $obj;
}
else {
if (isset($this->items[$key])) {
throw new KeyHasUseException("Key $key already in use.");
}
else {
$this->items[$key] = $obj;
}
}
}
The deleteItem()
and getItem()
methods take the key as a parameter indicating which items are targeted for removal or retrieval. An exception should be thrown if an invalid key is supplied.
public function deleteItem($key) {
if (isset($this->items[$key])) {
unset($this- >items[$key]);
}
else {
throw new KeyInvalidException("Invalid key $key.");
}
}
public function getItem($key) {
if (isset($this->items[$key])) {
return $this->items[$key];
}
else {
throw new KeyInvalidException("Invalid key $key.");
}
}
Because the $key parameter to the addItem()
method is optional, we won’t necessarily know the key used for each item in the collection. Adding a method that can provide a list of keys to any external code that might need it is a good idea. The keys can be returned as an array:
public function keys() {
return array_keys($this->items);
}
It might also be helpful to know how many items are in the collection.
public function length() {
return count($this->items);
}
And because getItem()
and deleteItem()
can throw an exception if an invalid key is passed, a means of determining whether a given key exists in the collection is also a good idea.
public function keyExists($key) {
return isset($this->items[$key]);
}
To use the Collection
class as it stands now, create the file Collection.php
and save the code for the Collection
class in it. Create files for the KeyInvalidException
and KeyhasUseException
classes, too (they can be simple sub-classes of the base Exception
class). Be sure to add require statements if you’re not using an autoloader, and then try the following test code:
<?php
require_once "Collection.php";
class Salut
{
private $name;
private $number;
public function __construct($name, $number) {
$this->name = $name;
$this->number = $number;
}
public function __toString() {
return $this->name . " is number " . $this->number;
}
}
$c = new Collection();
$c->addItem(new Salut("Steve", 14), "steve");
$c->addItem(new Salut("Ed", 37), "ed");
$c->addItem(new Salut("Bob", 49), "bob");
$c->deleteItem("steve");
try {
$c->getItem("steve");
}
catch (KeyInvalidException $e) {
print "The collection doesn't contain Steve.";
}
This example may not be particularly interesting, but it should give you an idea of how the class is used.
Conclusion
Collections can be seen as more-specialized way of working with lists for which certain contracts are guaranteed. A Collection class is a very useful OO alternative to the traditional array, and one that can be implemented in virtually any application you might build. It provides careful management of its members and a consistent API that makes it easy to write code that uses the class.Frequently Asked Questions (FAQs) about Collection Classes in PHP
What are the benefits of using collection classes in PHP?
Collection classes in PHP provide a more efficient way to handle data sets. They offer a structured, object-oriented approach to managing data, which can improve code readability and maintainability. Collection classes also provide a wide range of built-in methods for manipulating data, such as sorting, filtering, and mapping. This can save developers time and effort as they don’t need to write these functions from scratch. Additionally, collection classes can enhance performance, especially when dealing with large data sets, as they are optimized for efficient data handling.
How do I create a collection class in PHP?
Creating a collection class in PHP involves defining a class that encapsulates a group of objects. This class should include methods for adding, removing, and retrieving items from the collection. Here’s a basic example:class Collection
{
protected $items = [];
public function add($item)
{
$this->items[] = $item;
}
public function remove($item)
{
$index = array_search($item, $this->items);
if ($index !== false) {
unset($this->items[$index]);
}
}
public function getItems()
{
return $this->items;
}
}
How can I use Laravel collections?
Laravel collections provide a convenient, fluent interface for dealing with arrays of data. You can create a collection by using the collect
helper function, like so:$collection = collect([1, 2, 3, 4, 5]);
Once you have a collection, you can use various methods to manipulate the data. For example, you can use the map
method to apply a function to each item in the collection:$collection->map(function ($item, $key) {
return $item * 2;
});
What is the DS\Collection class in PHP?
The DS\Collection class is part of the PHP Data Structures extension (DS). It provides an interface that all the data structures in the DS extension adhere to. This means you can use the same methods to manipulate different types of data structures, such as stacks, queues, and vectors. However, please note that the DS extension is not included in PHP by default and needs to be installed separately.
How can I filter data in a collection?
Most collection classes provide a filter
method that allows you to remove items from the collection based on a callback function. Here’s an example:$collection = collect([1, 2, 3, 4, 5]);
$filtered = $collection->filter(function ($value, $key) {
return $value > 2;
});
In this example, the filter
method will remove any items from the collection that do not pass the provided test (in this case, values that are less than or equal to 2).
Can I use collection classes with databases in PHP?
Yes, collection classes can be very useful when working with databases in PHP. For example, Laravel’s Eloquent ORM returns query results as collection instances, allowing you to use collection methods to manipulate the data. This can make your code more readable and maintainable.
How can I sort data in a collection?
Most collection classes provide a sort
method that allows you to sort the items in the collection. You can provide a callback function to determine the sort order. Here’s an example:$collection = collect([5, 3, 1, 4, 2]);
$sorted = $collection->sort();
In this example, the sort
method will sort the items in ascending order.
What is the difference between arrays and collection classes in PHP?
While both arrays and collection classes can be used to store and manipulate data, there are some key differences. Collection classes are object-oriented and provide a wide range of built-in methods for manipulating data, which can make your code more readable and maintainable. On the other hand, arrays in PHP are basic data structures with a limited set of functions for data manipulation.
Can I convert a collection to an array?
Yes, most collection classes provide a method to convert the collection to an array. For example, in Laravel, you can use the toArray
method:$collection = collect([1, 2, 3, 4, 5]);
$array = $collection->toArray();
How can I iterate over a collection?
You can iterate over a collection in much the same way as you would an array, using a foreach
loop. Most collection classes also provide methods for iterating over the items in the collection, such as each
, map
, and filter
. Here’s an example:$collection = collect([1, 2, 3, 4, 5]);
$collection->each(function ($item, $key) {
echo $item;
});
In this example, the each
method will execute the provided callback for each item in the collection.
To whom it may concern, I'm Alireza. For a significant chunk of my waking hours I’m a PHP expert, Author, Speaker and independent consultant on the design of enterprise web applications with Master's degrees in Computer Science. I <3 Tech, But pass time away from computers as an aspiring amateur writer, fishing, traveling, hunting, soccer- I'm a massive Liverpool FC fan!