PHP7 powering the web a whole lot Better

December 12, 2024 9:13 pm

PHP7 powering the web a whole lot Better

{ 1 Comment}

PHP is one of the most popular programming languages for most of the web development companies today. 2015 has given a significant boost to PHP after eleven years of its release i.e. 5.0. At the end of 2015, PHP 7 was released which has brought many new features and impressive performance boosters.

PHP7 powering the web a whole lot Better

But how will this result on your current PHP codebase? What is revised in it? And is it safe to update?
This post will solve your queries and give you a complete guide to PHP 7.

An Introduction

PHP 7 is a brand new version of the engine coming under the code name of .

The Zend engine has been supplying PHP since 1999. It is important to note that Zend should not to confused with the Zend Framework, an open-source execution engine which is in C language that interprets the PHP language. The older version i.e. PHP 5.X series utilized Zend Engine II. It assisted in enhancing the functionality of the primary engine and added an extensible object model with significant performance enhancement to the language.

The Name’s PHP 7 (Not 5.7)

PHP 5.7 existed in the past as an experimental project but never reached the production phase. It was due to the Unicode problems that were supposed to be solved in version 5.7 which were unsuccessful, hence because of too many complications, and this kind of ruined things for everyone, it was decided to come up with .

Also Read:

New Features of PHP 7

Due to a new version of Zend Engine, PHP 7.0.0 offers the following features:

Constant arrays using define()
Spaceship Operator
Return Type Declarations
Scalar Type Declarations
PHP 7 enable to use Anonymous Classes
The null coalescing Operator (??)
Closure::call()
Filtered unserialize()
IntlChar
Anonymous Classes.
Expectations
Generator Return Expressions
Generator Delegation
Unicode codepoint escape syntax
CSPRNG Functions
preg_replace_callback_array()
Session options
Integer division with intdiv()
Group use Declarations

Some handpicked features of PHP 7 are explained here.

Scalar Type Deceleration

It is one of the most controversial change. The addition of this feature involved vote that almost passed. Multiple RFCs followed this, and a whole lot of confusion occurred which ultimately ended with moving the original RFC.
For the end-users, it only means that you can type-hint with scalar types. Specifically: integers, floating point numbers, string, and booleans. Default type-hints are non-strict, which denotes that they pressurize the original type to the type-hint type float (1.0).

<?php//use Coercive modefunction sumOfInts(int…$ints){return array_sum($ints);}var_dump(sumOfInts(2, 3′, 4.1));

<?php

//use Coercive mode

function sumOfInts(int...$ints)

{

return array_sum($ints);

}

var_dump(sumOfInts(2, 3‘, 4.1));

Return type declarations

The new PHP 7 adds support for return type declarations. It is just like argument type declarations using the same types which are available for return type declarations. The return type declarations specify the type of the value that will be returned from a function.

<?phpfunction arraysSum(array…$arrays): array{return array_map(function(array $array): int {return array_sum($array);}, $arrays);}print_r(arraysSum([1,2,3], [4,5,6], [7,8,9]));

<?php

function arraysSum(array...$arrays): array

{

return array_map(function(array $array): int {

return array_sum($array);

}, $arrays);

}

print_r(arraysSum([1,2,3], [4,5,6], [7,8,9]));

It will result into:

Array([0] => 6[1] => 15[2] => 24)

Array

(

[0] => 6

[1] => 15

[2] => 24

)

Null coalescing operator

The null coalescing operator (??) act as a syntactic sugar for using a ternary in conjunction with isset(). If it exists it return its first operand and is not NULL; otherwise it returns its second operand.

<?php// Fetches the value of $_GET[‘user’] and returns ‘nobody’// if it does not exist.$username = $_GET[‘user’] ?? ‘nobody’;// This is equivalent to:$username = isset($_GET[‘user’]) ? $_GET[‘user’] : ‘nobody’;// Coalescing can be chained: this will return the first// defined value out of $_GET[‘user’], $_POST[‘user’], and// ‘nobody’.$username = $_GET[‘user’] ?? $_POST[‘user’] ?? ‘nobody’;?>

<?php

// Fetches the value of $_GET[‘user’] and returns ‘nobody’

// if it does not exist.

$username = $_GET[‘user’] ?? ‘nobody’;

// This is equivalent to:

$username = isset($_GET[‘user’]) ? $_GET[‘user’] : ‘nobody’;

// Coalescing can be chained: this will return the first

// defined value out of $_GET[‘user’], $_POST[‘user’], and

// ‘nobody’.

$username = $_GET[‘user’] ?? $_POST[‘user’] ?? ‘nobody’;

Spaceship operator

The spaceship operator is used for comparing two expressions which is done according to PHP’s usual type comparison rules. It returns -1, 0 or 1 when $a is respectively less than, equal to, or greater than $b.

<?php// Integersecho 1 <=> 1; // 0echo 1 <=> 2; // -1echo 2 <=> 1; // 1// Floatsecho 1.5 <=> 1.5; // 0echo 1.5 <=> 2.5; // -1echo 2.5 <=> 1.5; // 1// Stringsecho “a” <=> “a”; // 0echo “a” <=> “b”; // -1echo “b” <=> “a”; // 1?>

<?php

// Integers

echo 1 <=> 1; // 0

echo 1 <=> 2; // -1

echo 2 <=> 1; // 1

// Floats

echo 1.5 <=> 1.5; // 0

echo 1.5 <=> 2.5; // -1

echo 2.5 <=> 1.5; // 1

// Strings

echo “a” <=> “a”; // 0

echo “a” <=> “b”; // -1

echo “b” <=> “a”; // 1

Constant arrays using

In PHP 5.6, Array were defined with const. But now with the PHP 7 Array constants are defined with define().

<?phpdefine(‘ANIMALS’, [‘dog’,’cat’,’bird’]);echo ANIMALS[1]; // outputs “cat”?>

<?php

define(‘ANIMALS’, [

‘dog’,

‘cat’,

‘bird’

]);

echo ANIMALS[1]; // outputs “cat”

PHP 7 enable to use Anonymous Classes

PHP 7 allow using Anonymous Classes which means a class without a name. The object it instantiates has the same functionality as an object of a named class. If they are used well, they may speed up coding as well execution time.

<?phpinterface Logger {public function og(string msg);}class Application {private $logger;public function getLogger(): Logger {return $this->logger;}public function setLogger(Logger $logger) {$this->logger = $logger;}}$app = new Application;$app->setLogger(new class implements Logger {public function log(string $msg) {echo $msg;}});var_dump($app->getLogger());?>

<?php

interface Logger {

public function og(string msg);

}

class Application {

private $logger;

public function getLogger(): Logger {

return $this->logger;

}

public function setLogger(Logger $logger) {

$this->logger = $logger;

}

$app = new Application;

$app->setLogger(new class implements Logger {

public function log(string $msg) {

echo $msg;

}

});

var_dump($app->getLogger());

The example will result into:

object(class@anonymous)#2 (0) {}Closure::call()Closure::call() is shorthand way of temporarily binding an object scope to a closure.<?phpclass A {private $x = 1;}// Pre PHP 7 code$getXCB = function() {return $this->x;};$getX = $getXCB->bindTo(new A, ‘A’); // intermediate closureecho $getX();// PHP 7+ code$getX = function() {return $this->x;};echo $getX->call(new A);The above example will result into:11

object(class@anonymous)#2 (0) {

}

Closure::call()

Closure::call() is shorthand way of temporarily binding an object scope to a closure.

<?php

class A {private $x = 1;}

// Pre PHP 7 code

$getXCB = function() {return $this->x;};

$getX = $getXCB->bindTo(new A, ‘A’); // intermediate closure

echo $getX();

// PHP 7+ code

$getX = function() {return $this->x;};

echo $getX->call(new A);

The above example will result into:

Filtered unserialize()

It is useful to provide provide better security while unserializing objects on untrusted data. It prevents possible code injections by enabling the developer to whitelist classes that can be unserialized.

<?php// converts all objects into __PHP_Incomplete_Class object$data = unserialize($foo, [“allowed_classes” => false]);// converts all objects into __PHP_Incomplete_Class object except those of MyClass and MyClass2$data = unserialize($foo, [“allowed_classes” => [“MyClass”, “MyClass2”]]);// default behaviour (same as omitting the second argument) that accepts all classes$data = unserialize($foo, [“allowed_classes” => true]);

<?php

// converts all objects into __PHP_Incomplete_Class object

$data = unserialize($foo, [“allowed_classes” => false]);

// converts all objects into __PHP_Incomplete_Class object except those of MyClass and MyClass2

$data = unserialize($foo, [“allowed_classes” => [“MyClass”, “MyClass2”]]);

// default behaviour (same as omitting the second argument) that accepts all classes

$data = unserialize($foo, [“allowed_classes” => true]);

IntlChar

The new IntlChar class seeks to provide additional ICU functionality. The class itself defines a number of static methods and constants that can be used to manipulate unicode characters.

<?phpprintf(‘%x’, IntlChar::CODEPOINT_MAX);echo IntlChar::charName(‘@’);var_dump(IntlChar::ispunct(‘!’));The above example will output:10ffffCOMMERCIAL ATbool(true)

<?php

printf(‘%x’, IntlChar::CODEPOINT_MAX);

echo IntlChar::charName(‘@’);

var_dump(IntlChar::ispunct(‘!’));

The above example will output:

10ffff

COMMERCIAL AT

bool(true)

Expectations

Expectations are a backwards compatible enhancement to the older assert() function. They allow for zero-cost assertions in production code, and provide the ability to throw custom exceptions when the assertion fails.

<?phpini_set(‘assert.exception’, 1);class CustomError extends AssertionError {}assert(false, new CustomError(‘Some error message’));?>

<?php

ini_set(‘assert.exception’, 1);

class CustomError extends AssertionError {}

assert(false, new CustomError(‘Some error message’));

The above example will output:

Fatal error: Uncaught CustomError: Some error message

Generator Return Expressions

This feature was introduced into PHP 5.5. It builds upon the generator functionality. This value can be fetched using the newGenerator::getReturn(), method, which may only be used once the generator has finishing yielding values.

<?php$gen = (function() {yield 1;yield 2;return 3;})();foreach ($gen as $val) {echo $val, PHP_EOL;}echo $gen->getReturn(), PHP_EOL;

<?php

$gen = (function() {

yield 1;

yield 2;

return 3;

})();

foreach ($gen as $val) {

echo $val, PHP_EOL;

}

echo $gen->getReturn(), PHP_EOL;

The above example will output:

123

Unicode codepoint escape syntax

Here Unicode takes the codepoint into hexadecimal form and interprets the same codepoint into doubled quoted string or heredoc- UTF-8.

echo “\u{aa}”;echo “\u{0000aa}”;echo “\u{9999}”;The above example will output:ªª (same as before but with optional leading 0’s)香

echo “\u{aa}”;

echo “\u{0000aa}”;

echo “\u{9999}”;

The above example will output:

ª (same as before but with optional leading 0‘s)

香

Wrapping up

PHP is upgraded to improve its performance. The improved version has introduced as phpng. The increased performance may ensure quick adoption, especially from smaller hosts, as they will be able to host maximum users on the same hardware. In addition to performance, PHP 7 is also expected to save a substantial amount of memory, as optimization of internal data structures is one of the fundamental ways in which performance enhancement have been achieved. Let’s go PHP!

Tutorial Categories:

嘉盛

Facebook

Tutorial Categories:

One response to “PHP7 powering the web a whole lot Better”

omerida says:
February 8, 2016 at 2:57 pm
PHP 5.7? Technically, that’s correct in that the last branch of the 5.x series is 5.6 not 5.7. But the reason the PHP project released this is version 7 is that it introduced new features which break compatibility with its predecessor.
Did you mean to instead clarify that PHP 7 skipped the illfated PHP 6 branch (which is where the Unicode work was attempted)?
Reply