New OOP Features
in PHP 5.5
Matthew Turland
I Co/Wrote These
</ShamelessPlug>
Advantages of Generators
- Generate values as they're needed
- Use less memory because all values aren't stored in memory —
think PDOStatement::fetch() versus PDOStatement::fetchAll()
- Use less CPU to generate values if not all values are needed
- Require less code than a full custom iterator implementation
Disadvantages vs Iterators
- Are unidirectional and can't be rewound
- Can lead to spaghetti code; use iterators where they're more appropriate
An Improved file()
Example also lifted from the Generators RFC
(Hint: You should probably read this thing.)
Iterators vs Generators: Example
Iterators vs Generators: Comparison
- Less than half the lines of code
- No support for value keys
- No rewind support
Coroutines
Coroutines are like generators in reverse: they consume data.
Coroutines and Exceptions
Analog to Streams
- streams : strings :: generators/coroutines : PHP type
- stream filters : functions that are both generators and coroutines
In a Nutshell
- Use generators when you:
- need to iterate once over a sequence of values
- don't want to generate all values at once
- don't want to store all values in memory at once
- don't want to implement an iterator class
- Use coroutines to supplement generators for filtering, transformation, and other manipulation of generated values
- For the love of all that is sacred, Don't Be Evil™
Finally! finally!
- Simplifies execution of cleanup logic in code with exception handling
- Used in other languages like Java, JavaScript, Python, and Ruby
finally blocks are executed whenever execution of try or catch blocks terminates
Practical Example of finally
Example lifted from the finally RFC
How finally Works
With Exceptions
How finally Works
Without Exceptions
How finally Works
With Returns
finally in a nutshell
- Use when cleanup logic must run regardless of whether exceptions occur:
- Closing a database connection
- Closing a stream, e.g. for an open file
- Deleting a temporary file
- "For when it absolutely, positively must be executed"
Using ::class with Doctrine
Using ::class with Pimple
Using ::class with general PHP
Special ::class Resolutions
self::class resolves the same as __CLASS__ wouldstatic::class resolves the same as get_called_class() wouldparent::class resolves the same as get_parent_class() would; returns false if not inheritedstatic::class and parent::class will cause an exception when used in compile-time only places like method signatures
::class in a Nutshell
Use in dynamic instantiation of classes
- Mocking in unit tests
- Reflection
- Dependency injection
- Adapters
- Factories
Non-Scalar Keys in foreach
Iterator::key() was able to return any data type, but foreach didn't handle non-scalar values correctly prior to 5.5- This made some use cases for classes that support non-scalar keys, like
SplObjectStorage, unnecessarily complicated
- The fix is limited to iterators; it does not affect arrays
Why Use Non-Scalar Keys?
- Storing related data external to immutable objects (e.g. mapping connection objects to associated stream resources or vice versa)
- Less memory usage versus duplicating or generating object identifiers as array keys (e.g.
spl_object_hash()) and fewer values to keep track of
Where to Find Me
