Nouvelles fonctionnalités

Déclarations du type scalaire

Les déclarations de type scalaire viennent en deux modes : coercitive (par défaut) ou stricte. Les types de paramètres suivants peuvent être renforcés (soit coercitif soit strict) : les chaînes de caractères (string), les entiers (int), les décimaux (float) et les valeurs booléennes (bool). Ils complémentent les autres types introduits dans PHP 5 : les noms des classes, les interfaces, les tableaux (array) et les fonctions appelables (callable).

<?php
// Mode coercitive
function sommeEntiers(int ...$entiers)
{
    return 
array_sum($entiers);
}

var_dump(sommeEntiers(2'3'4.1));

L'exemple ci-dessus va afficher :

int(9)

Pour activer le mode strict, une seule directive declare doit être placée en haut du fichier. Ceci signifie que le mode strict de déclaration du type scalaire est configurée par fichier. La directive n'affecte pas seulement la déclaration des paramètres mais aussi le type de retour de la fonction (voir les déclarations du type de retour dans les fonctions PHP et celles issues des extensions).

Une documentation complète et des exemples de déclarations du type scalaire peuvent être trouvés dans la référence : Déclarations de type.

Déclarations du type de retour

PHP 7 ajoute un support pour les déclarations du type de retour. Similaires aux déclarations du type d'argument, les déclarations du type de retour spécifient le type de la valeur qui sera retournée par la fonction. Les mêmes types qui sont disponibles pour les déclarations du type de retour sont disponibles pour les déclarations du type d'argument.

<?php

function sommeTableaux(array ...$tableaux): array
{
    return 
array_map(function(array $tableaux): int {
        return 
array_sum($tableaux);
    }, 
$tableaux);
}

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

L'exemple ci-dessus va afficher :

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

Une documentation complète et des exemples de déclarations du type de retour peuvent être trouvés dans la référence : Déclarations du type de retour.

L'opérateur Null coalescent

L'opérateur Null coalescent (??) a été ajouté comme un sucre syntaxique pour les cas de besoin le plus commun d'utiliser une troisième conjonction avec la fonction isset(). Il retourne le premier opérande s'il existe et n'a pas une valeur NULL; et retourne le second opérande sinon.

<?php
// Récupére la valeur de $_GET['utilisateur'] retourne 'aucun'
// s'il n'existe pas.
$identifiant $_GET['utilisateur'] ?? 'aucun';
// Ceci est équivalent à :
$identifiant = isset($_GET['utilisateur']) ? $_GET['utilisateur'] : 'aucun';

// L'opérateur permet de faire du chaînage : Ceci va retourner la première
// valeur définie respectivement dans $_GET['utilisateur'], $_POST['utilisateur']
// et 'aucun'.
$identifiant $_GET['utilisateur'] ?? $_POST['utilisateur'] ?? 'aucun';
?>

L'opérateur Spaceship

L'opérateur Spaceship est utilisé pour comparer deux expressions. Il retourne -1, 0 ou 1 quand $a est respectivement inférieur, égale ou supérieur à $b. Les comparaisons sont effectuées selon les règles de comparaison de types habituelles de PHP.

<?php
// Entiers
echo <=> 1// 0
echo <=> 2// -1
echo <=> 1// 1

// Nombres à virgule flottante
echo 1.5 <=> 1.5// 0
echo 1.5 <=> 2.5// -1
echo 2.5 <=> 1.5// 1
 
// Chaînes de caractères
echo "a" <=> "a"// 0
echo "a" <=> "b"// -1
echo "b" <=> "a"// 1
?>

Les tableaux constants à l'aide de define()

Les tableaux (Array) constants peuvent maintenant être définis avec la fonction define(). Dans PHP 5.6, ils pouvaient être défini seulement avec const.

<?php
define
('ANIMAUX', [
    
'chien',
    
'chat',
    
'oiseau'
]);

echo 
ANIMAUX[1]; // affiche "chat"
?>

Les classes anonymes

La prise en charge des classes anonymes a été ajouté à travers l'instanciation new class. Celle-ci peut être utilisée au lieu de définir toute une classe pour des objets jetables :

<?php
interface Logger {
    public function 
log(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());
?>

L'exemple ci-dessus va afficher :

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

La documentation complète peut être trouvée dans la référence des classes anonymes.

Syntaxe d’échappement du point de code Unicode

Cela prend un point de code Unicode sous forme hexadécimale, dans une chaîne entre doubles guillemets ou une syntaxe heredoc, pour le convertir en UTF-8. N’importe quel point de code valide est accepté, les zéros en début de chaîne étant facultatifs.

echo "\u{aa}";
echo "\u{0000aa}";
echo "\u{9999}";

L'exemple ci-dessus va afficher :

ª
ª (même affichage que la ligne précédente mais avec des zéros en début de chaîne)
香

Closure::call()

La méthode Closure::call() est devenue plus performante. Une façon plus courte de lier temporairement une fermeture à la portée d'un objet et l'invoquer.

<?php
class {private $x 1;}

// Code avant PHP 7
$getX = function() {return $this->x;};
$getXCB $getX->bindTo(new A'A'); // fermeture intermédiaire
echo $getXCB();

// Code PHP 7+
$getX = function() {return $this->x;};
echo 
$getX->call(new A);

L'exemple ci-dessus va afficher :

1
1

unserialize() est filtrée

Cette fonctionnalité vise à garantir une meilleure sécurité lorsque la désérialisation d’objets est effectuée avec des données non fiables. Elle empêche les injections de code possible en permettant au développeur de whitelister les classes qui peuvent être désérialisées.

<?php

// Convertit tous les objets vers un objet __PHP_Incomplete_Class
$data unserialize($foo, ["allowed_classes" => false]);

// Convertit tous les objets vers un objet __PHP_Incomplete_Class 
// excepté ceux de MyClass et MyClass2
$data unserialize($foo, ["allowed_classes" => ["MyClass""MyClass2"]]);

// Comportement par défaut (le même que lorsqu'on omet le deuxième argument) 
// qui accepte toutes les classes
$data unserialize($foo, ["allowed_classes" => true]);

IntlChar

La nouvelle classe IntlChar cherche à exposer la fonctionnalité ICU en plus. La classe elle-même définit un nombre de méthodes statiques et de constantes qui peuvent être utilisées pour manipuler les caractères unicode.

<?php

printf
('%x'IntlChar::CODEPOINT_MAX);
echo 
IntlChar::charName('@');
var_dump(IntlChar::ispunct('!'));

L'exemple ci-dessus va afficher :

10ffff
COMMERCIAL AT
bool(true)

Pour utiliser cette classe, vous devez installer l'extension Intl.

Les attentes

Les attentes sont une amélioration rétro-compatible apportée à l'ancienne fonction assert(). Ils offrent des assertions à très faible coût dans le code de production et permettent de lever des exceptions personnalisées lorsque l’assertion échoue.

Alors que l'ancienne API continue à être maintenue pour des raisons de compatibilité, la fonction assert() est maintenant une construction de language, permettant au premier paramètre d'être une expression plutôt qu'un string à évaluer ou un boolean à tester.

<?php
ini_set
('assert.exception'1);

class 
CustomError extends AssertionError {}

assert(false, new CustomError('Un message d\'erreur'));
?>

L'exemple ci-dessus va afficher :

Fatal error: Uncaught CustomError: Un message d\'erreur

On trouvera plus de détails sur cette fonctionnalité, y compris la façon de le configurer dans les environnements de développement et de production, dans la section attentes dans la référence de la fonction assert().

Grouper les déclarations use

Les classes, les fonctions and les constantes importées à partir du même namespace peuvent être groupées maintenant dans une seule instruction use.

<?php
// Code avant PHP 7
use some\namespace\ClassA;
use 
some\namespace\ClassB;
use 
some\namespace\ClassC as C;

use function 
some\namespace\fn_a;
use function 
some\namespace\fn_b;
use function 
some\namespace\fn_c;

use const 
some\namespace\ConstA;
use const 
some\namespace\ConstB;
use const 
some\namespace\ConstC;

// Code PHP 7+
use some\namespace\{ClassAClassBClassC as C};
use function 
some\namespace\{fn_afn_bfn_c};
use const 
some\namespace\{ConstAConstBConstC};
?>

Expressions de retour générateur

Cette fonction se base sur la fonctionnalité de générateur introduite dans PHP 5.5. Il permet d'utiliser une instruction return dans un générateur pour retourner une expression finale (le retour par référence n'est pas autorisé). Cette valeur peut être extraite en utilisant la nouvelle méthode Generator::getReturn(), qui ne peut être utilisé que lorsque le générateur a fini de rendre les valeurs.

<?php

$gen 
= (function() {
    
yield 1;
    
yield 2;

    return 
3;
})();

foreach (
$gen as $val) {
    echo 
$valPHP_EOL;
}

echo 
$gen->getReturn(), PHP_EOL;

L'exemple ci-dessus va afficher :

1
2
3

C'est très pratique d'être capable de renvoyer explicitement une valeur finale d'un générateur. Car cela permet à une valeur finale, susceptible d'être gérée spécialement par le code client exécutant le générateur, d'être retourné par le générateur (peut-être à partir d'une forme de calcul coroutine). C'est de loin plus simple que de forcer le code client à vérifier d'abord si la valeur finale a été rendue, puis de gérer spécifiquement la valeur quand c'est le cas.

Délégation de générateur

Les générateurs peuvent maintenant être délégués automatiquement à un autre générateur, un objet Traversable ou un array, en utilisant yield from, sans avoir recours à un boilerplate.

<?php
function gen()
{
    
yield 1;
    
yield 2;
    
yield from gen2();
}

function 
gen2()
{
    
yield 3;
    
yield 4;
}

foreach (
gen() as $val)
{
    echo 
$valPHP_EOL;
}
?>

L'exemple ci-dessus va afficher :

1
2
3
4

La division d’entiers avec intdiv()

La nouvelle fonction intdiv() retourne le résultat de la division d'entiers effectuée sur ses opérandes.

<?php
var_dump
(intdiv(103));
?>

L'exemple ci-dessus va afficher :

int(3)

Les options de session

La fonction session_start() accepte maintenant un array d'options qui surcharge les directives de configuration de session manuellement configurées dans le fichier php.ini.

Ces options ont aussi étendu le support pour l'option session.lazy_write, qui est activé par défaut et pousse PHP à surcharger les fichiers de session seulement si les données de session ont été mis à jour, et l'option read_and_close, ne pouvant être passé à la fonction session_start() que pour indiquer si les données de session doivent être lu avant que la session soit terminée sans changements.

Par exemple, pour mettre session.cache_limiter à private et fermer immédiatement la session après l'avoir lu :

<?php
session_start
([
    
'cache_limiter' => 'private',
    
'read_and_close' => true,
]);
?>

preg_replace_callback_array()

La nouvelle fonction preg_replace_callback_array() permet au code d'être écrit de façon plus propre en utilisant la fonction preg_replace_callback(). Avant PHP 7, les fonctions de rappel (callback) devaient être exécutées par expression régulière ce qui demande à la fonction de rappel d'être sali avec beaucoup de ramifications.

Maintenant, les fonctions de rappel peuvent être enregistrés pour chaque expression régulière en utilisant un tableau associatif, là où la clé est une expression régulière ayant la fonction de rappel comme valeur.

Les fonctions CSPRNG

Deux nouvelles fonctions ont été ajoutée pour générer cryptographiquement des entiers et des chaînes de caractères sécurisés de façon multi-plateforme : random_bytes() et random_int().

La fonction list() peut toujours déballer les objets qui implémentent ArrayAccess

Auparavant, la fonction list() ne pouvait pas opérer à 100% sur des objets qui implémentent ArrayAccess. Maintenant, ça a été corrigé.

Autres fonctionnalités

  • L'accès aux membres de la classe (attributs et méthodes) lors du clonage a été ajouté. Exemple, (clone $foo)->bar().
add a note add a note

User Contributed Notes 5 notes

up
73
PawelD
1 year ago
<?php
class foo { static $bar = 'baz'; }
var_dump('foo'::$bar);
?>

if < php7.0

then we will receive a syntax error, unexpected '::' (T_PAAMAYIM_NEKUDOTAYIM)

but php7 returns string(3) "baz"

I think it's not documented anywhere
up
3
TerryE
5 months ago
$a = ''; // or 0 or false

$b = $a ?? 'a'; 
// $b is '' or 0 or false

$c = $a ?: 'a';
// $c is 'a'
up
-13
omarv_r at yahoo dot com
1 year ago
lexx918, It is not working unexpectedly... lets see:

Calling to isset() method for a non existing property ($foo->bar in this case), automatically the magic method __isset() is invoked. So

$a = isset($foo->bar) ?: null; // __isset

is correct.

But when we try to evaluate $foo->bar, we are calling a getter. Because the bar property does not exist, the implicit calling is to magic method __get(). So

$a = $foo->bar ?? null; // __get

is correct too.
up
-13
robert.j.pounder
5 months ago
<?php
class foo { static $bar = 'baz'; }
var_dump('foo'::$bar);

and
variations dont work

but

<?php
class foo { static $bar = 'baz'; }
$t = 'foo';
var_dump($t::$bar);

works < 7.0
up
-70
lexx918 at mail dot ru
1 year ago
Sugar of ternary operator:
<?php
$a
?? 'b'
// allegedly equivalent to
isset($a) ? $a : 'b'
?>
.. in classes working unexpectedly:
<?php
class Foo {
    public function
__get($p) { echo "__get" . PHP_EOL; }
    public function
__isset($p) { echo "__isset" . PHP_EOL; }
}
$foo = new Foo;
$a = isset($foo->bar) ?: null; // __isset
$a = $foo->bar ?? null; // __get
?>
To Top