php recoursive,PHP: Nouvelles fonctionnalités - Manual

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 (

{

returnarray_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.

{

returnarray_map(function(array$tableaux):int{

returnarray_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 null; et retourne le second opérande sinon.

// 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,

égal ou supérieur à $b. Les comparaisons sont effectuées

selon

les règles de comparaison de types

habituelles de PHP.

<?php // Entiersecho1<=>1;// 0echo1<=>2;// -1echo2<=>1;// 1

// Nombres à virgule flottanteecho1.5<=>1.5;// 0echo1.5<=>2.5;// -1echo2.5<=>1.5;// 1

// Chaînes de caractèresecho"a"<=>"a";// 0echo"a"<=>"b";// -1echo"b"<=>"a";// 1?>

Les tableaux constants à l'aide de

Les tableaux (Array) constants peuvent maintenant être définis

avec la fonction const.

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

echoANIMAUX[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 :

public functionlog(string $msg);

}

classApplication{

private$logger;

public functiongetLogger():Logger{

return$this->logger;

}

public functionsetLogger(Logger $logger) {$this->logger=$logger;

}

}$app= newApplication;$app->setLogger(new class implementsLogger{

public functionlog(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)

香

La méthode

<?phpclassA {private$x=1;}// Code avant PHP 7$getX= function() {return$this->x;};$getXCB=$getX->bindTo(newA,'A');// fermeture intermédiaireecho$getXCB();// Code PHP 7+$getX= function() {return$this->x;};

echo$getX->call(newA);

L'exemple ci-dessus va afficher :

1

1

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]);

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.

printf('%x',IntlChar::CODEPOINT_MAX);

echoIntlChar::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

Alors que l'ancienne API continue à être maintenue pour des raisons de

compatibilité, la fonction string à évaluer ou un

bool à tester.

ini_set('assert.exception',1);

classCustomErrorextendsAssertionError{}assert(false, newCustomError('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

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.

usesome\namespace\ClassB;

usesome\namespace\ClassCasC;

use functionsome\namespace\fn_a;

use functionsome\namespace\fn_b;

use functionsome\namespace\fn_c;

use constsome\namespace\ConstA;

use constsome\namespace\ConstB;

use constsome\namespace\ConstC;// Code PHP 7+usesome\namespace\{ClassA,ClassB,ClassCasC};

use functionsome\namespace\{fn_a,fn_b,fn_c};

use constsome\namespace\{ConstA,ConstB,ConstC};?>

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.

$gen= (function() {

yield1;

yield2;

return3;

})();

foreach ($genas$val) {

echo$val,PHP_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.

{

yield1;

yield2;

yield fromgen2();

}

functiongen2()

{

yield3;

yield4;

}

foreach (gen() as$val)

{

echo$val,PHP_EOL;

}?>

L'exemple ci-dessus va afficher :

1

2

3

4

La division d’entiers avec

La nouvelle fonction

var_dump(intdiv(10,3));?>

L'exemple ci-dessus va afficher :

int(3)

Les options de session

La fonction 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

Par exemple, pour mettre session.cache_limiter

à private et fermer immédiatement la session après l'avoir lu :

session_start(['cache_limiter'=>'private','read_and_close'=>true,

]);?>

La nouvelle fonction

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 :

La fonction ArrayAccess

Auparavant, la fonction 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().