PHP 7 will be released in mid-October 2015 and includes many new features and performance improvements. Some key changes include scalar type hints, return type declarations, the null coalesce operator, and generator return expressions and delegation. PHP 7 also aims to fix inconsistencies, introduce uniform variable syntax, and make compile times faster while using more memory. It will be backwards incompatible by removing deprecated functionality and changing some syntax rules. Engine exceptions will also allow catching of fatal errors.

1. PHP 7
What’s new in PHP 7
By: Joshua Copeland

2. Joshua Copeland
 PHP lover for 7+ years
 Lead Developer at The Selling Source (we need a DBA)
 Father, husband, and overall awesome guy
 Software Developer for over 10 years
 First human to be a computer
 My Twitter Handle : @PsyCodeDotOrg

3. Proposed Milestones
 1. Line up any remaining RFCs that target PHP 7.0.
 2. Finalize implementation & testing of new features.
Mar 16 - Jun 15 (3 months)
 3. Release Candidate (RC) cycles
Jun 16 - Oct 15 (3 months)
 4. GA/Release
Mid October 2015
 https://wiki.php.net/rfc/php7timeline

4. Inconsistency Fixes
 Abstract Syntax Tree (AST)
 Decoupled the parser from the compiler.
 list() currently assigns variables right-to-left, the AST implementation
will assign them left-to-right instead.
 Auto-vivification order for by-reference assignments.
 10-15% faster compile times, but requires more memory.
 Directly calling __clone is allowed
https://wiki.php.net/rfc/abstract_syntax_tree

5. Uniform Variable Syntax
 Introduction of an internally consistent and complete variable
syntax. To achieve this goal the semantics of some rarely used
variable-variable constructions need to be changed.
 Call closures assigned to properties using ($object->closureProperty)()
 Chain static calls. Ex: $foo::$bar::$bat
 Semantics when using variable-variables/properties
 https://wiki.php.net/rfc/uniform_variable_syntax

6. Biggest reason to update

7. Biggest reason to update
Performance!
PHP 7 is on par with HHVM
Memory Savings

8. Backwards Incompatible Changes
 Call to member function on a non-object now catchable fatal error.
https://wiki.php.net/rfc/catchable-call-to-member-of-non-object
 ASP and script tags have been removed
Ex. <% <%= <script language=“php”></script>
 Removal of all deprecated functionality.
https://wiki.php.net/rfc/remove_deprecated_functionality_in_php7
 Removal of the POSIX compatible regular expressions extension, ext/ereg
(deprecated in 5.3) and the old ext/mysql extension (deprecated in 5.5).
 Switch statements throw and error when more than one default case found.

9. New Features
 Scalar type hints (omg yes)
https://wiki.php.net/rfc/scalar_type_hints_v5
 Weak comparison mode will cast to the type you wish.
 Strict comparison will throw a catchable fatal.
Turn on with declare(strict_types=1);
function sendHttpStatus(int $statusCode, string $message) {
header('HTTP/1.0 ' .$statusCode. ' ' .$message);
}
sendHttpStatus(404, "File Not Found"); // integer and string passed
sendHttpStatus("403", "OK"); // string "403" coerced to int(403)

10. New Features
 Return Type Hints
 https://wiki.php.net/rfc/return_types
 String, int, float, bool
 Same rules apply with weak and strict modes as parameter
type hints.

11. New Features
 Combined Comparison Operator
https://wiki.php.net/rfc/combined-comparison-operator
 AKA Starship Operator <=>
 Great for sorting,
returns -1 if value to the right, 0 if same, etc.
// Pre Spacefaring PHP 7
function order_func($a, $b) {
return ($a < $b) ? -1 : (($a > $b) ? 1 : 0);
}
// Post PHP 7
function order_func($a, $b) {
return $a <=> $b;
}

12. New Features
 Unicode Codepoint Escape Syntax
The addition of a new escape character, u, allows us to specify Unicode
character code points (in hexidecimal) unambiguously inside PHP strings:
The syntax used is u{CODEPOINT}, for example the green heart, 💚,
can be expressed as the PHP string: "u{1F49A}".

13. New Features
 Null Coalesce Operator
Another new operator, the Null Coalesce Operator, ??
It will return the left operand if it is not NULL, otherwise it will return the right.
The important thing is that it will not raise a notice if the left operand is a non-
existent variable. This is like isset() and unlike the ?: short ternary operator.
You can also chain the operators to return the first non-null of a given set:
$config = $config ?? $this->config ?? static::$defaultConfig;

14. New Features
 Bind Closure on Call
With PHP 5.4 we saw the addition of Closure->bindTo() and Closure::bind() which
allows you change the binding of $this and the calling scope, together, or separately,
creating a duplicate closure.
PHP 7 now adds an easy way to do this at call time, binding both $this and the calling
scope to the same object with the addition of Closure->call(). This method takes the
object as it’s first argument, followed by any arguments to pass into the closure, like
so:
class HelloWorld { private $greeting = "Hello"; }
$closure = function($whom) { echo $this->greeting . ' ' . $whom; }
$obj = new HelloWorld();
$closure->call($obj, 'World'); // Hello World

15. New Features
 Group Use Declarations
// Original
use FrameworkComponentSubComponentClassA;
use FrameworkComponentSubComponentClassB as ClassC;
use FrameworkComponentOtherComponentClassD;
// With Group Use
use FrameworkComponent{
SubComponentClassA,
SubComponentClassB as ClassC,
OtherComponentClassD
};

16. New Features
 Group Use Declarations
It can also be used with constant and function imports with use function, and use const,
as well as supporting mixed imports:
use FrameworkComponent{
SubComponentClassA,
function OtherComponentsomeFunction,
const OtherComponentSOME_CONSTANT
};

17. New Features
 Generator Return Expressions
There are two new features added to generators. The first is Generator Return
Expressions, which allows you to now return a value upon (successful) completion of a
generator.
Prior to PHP 7, if you tried to return anything, this would result in an error. However,
now you can call $generator->getReturn() to retrieve the return value.
If the generator has not yet returned, or has thrown an uncaught exception, calling
$generator->getReturn() will throw an exception. If the generator has completed but
there was no return, null is returned.
https://wiki.php.net/rfc/generator-return-expressions

18. New Features
 Generator Return Expressions
function gen() {
yield "Hello";
yield " ";
yield "World!";
return "Goodbye Moon!”;
}
$gen = gen();
foreach ($gen as $value) { echo $value; }
// Outputs "Hello" on iteration 1, " " on iterator 2, and "World!" on iteration 3 echo
$gen->getReturn(); // Goodbye Moon!
https://wiki.php.net/rfc/generator-return-expressions

19. New Features
 Generator Delegation
The second feature is much more exciting: Generator Delegation. This allows you to
return another iterable structure that can itself be traversed — whether that is an array,
an iterator, or another generator.
It is important to understand that iteration of sub-structures is done by the outer-most
original loop as if it were a single flat structure, rather than a recursive one.
This is also true when sending data or exceptions into a generator. They are passed
directly onto the sub-structure as if it were being controlled directly by the call.
This is done using the yield from <expression> syntax

20. New Features
 Generator Delegation
function hello() {
yield "Hello";
yield " ";
yield "World!";
yield from goodbye(); }
function goodbye() {
yield "Goodbye";
yield " ";
yield "Moon!"; }
$gen = hello();
foreach ($gen as $value) { echo $value; }
On each iteration, this will output:
"Hello"
" "
"World!”
"Goodbye"
" "
"Moon!"

21. New Features
 Engine Exceptions
Handling of fatal and catchable fatal errors has traditionally been impossible, or at
least difficult, in PHP. But with the addition of Engine Exceptions, many of these
errors will now throw exceptions instead. Now, when a fatal or catchable fatal error
occurs, it will throw an exception, allowing you to handle it gracefully. If you do
not handle it at all, it will result in a traditional fatal error as an uncaught exception.
These exceptions are EngineException objects, and unlike all userland
exceptions, do not extend the base Exception class. This is to ensure that existing
code that catches the Exception class does not start catching fatal errors moving
forward. It thus maintains backwards compatibility. In the future, if you wish to
catch both traditional exceptions and engine exceptions, you will need to catch
their new shared parent class, BaseException. Additionally, parse errors in
eval()’ed code will throw a ParseException, while type mismatches will throw a
TypeException.

22. New Features
 Engine Exceptions
try {
nonExistentFunction();
}
catch (EngineException $e) {
var_dump($e);
}
object(EngineException)#1 (7) {
["message":protected]=> string(32) "Call to undefined function nonExistantFunction()"
["string":"BaseException":private]=> string(0) ""
["code":protected]=> int(1)
["file":protected]=> string(17) "engine-exceptions.php" ["line":protected]=> int(1)
["trace":"BaseException":private]=> array(0) { }
["previous":"BaseException":private]=> NULL
}

23. More Info & Credits
 Slides info from
 https://blog.engineyard.com/2015/what-to-expect-php-7-2
 Infographic
 https://pages.zend.com/ty-infographic.html
 RFC
 https://wiki.php.net/rfc/php7timeline