PHP
Type de conseil

Syntaxe

• fonction f (NomClasse $ param) {}
• fonction f (bool $ param) {}
• fonction f (int $ param) {}
• fonction f (float $ param) {}
• fonction f (chaîne $ param) {}
• fonction f (self $ param) {}
• fonction f (callable $ param) {}
• fonction f (tableau $ param) {}
• function f (? type_name $ param) {}
• function f (): nom_type {}
• fonction f (): void {}
• function f ():? nom_type {}

Remarques

Tapez les types scalaires, les tableaux et les callables

La prise en charge des paramètres de tableau de type indice (et le retour des valeurs après PHP 7.1) a été ajoutée à PHP 5.1 avec le array mots-clés. Les tableaux de toutes dimensions et de tous types, ainsi que les tableaux vides, sont des valeurs valides.

Le support des callables de type hinting a été ajouté dans PHP 5.4. Toute valeur is_callable() est valide pour les paramètres et les valeurs de retour appelées callable , à savoir les objets de Closure , les chaînes de noms de fonctions et les array(class_name|object, method_name) .

Si une faute de frappe se produit dans le nom de la fonction de telle sorte qu'elle ne soit pas is_callable() , un message d'erreur moins évident serait affiché:

Erreur irrécupérable: TypeError Uncaught: l'argument 1 transmis à foo () doit être du type callable, string / array donné

function foo(callable $c) {}
foo("count"); // valid
foo("Phar::running"); // valid
foo(["Phar", "running"); // valid
foo([new ReflectionClass("stdClass"), "getName"]); // valid
foo(function() {}); // valid

foo("no_such_function"); // callable expected, string given

Les méthodes non statiques peuvent également être transmises en tant qu'appelants au format statique, ce qui entraîne un avertissement de dépréciation et une erreur de niveau E_STRICT dans PHP 7 et 5 respectivement.

La visibilité de la méthode est prise en compte. Si le contexte de la méthode avec le paramètre callable n'a pas accès à l'appelable fourni, il se retrouvera comme si la méthode n'existait pas.

class Foo{
  private static function f(){
    echo "Good" . PHP_EOL;
  }

  public static function r(callable $c){
    $c();
  }
}

function r(callable $c){}

Foo::r(["Foo", "f"]);
r(["Foo", "f"]);

Sortie:

Erreur irrécupérable: UnError TypeError: L'argument 1 transmis à r () doit pouvoir être appelé, tableau donné

La prise en charge des types scalaires de type hinting a été ajoutée en PHP 7. Cela signifie que nous prenons en charge les indications de type pour les integer boolean , les integer , les integer float et les string .

<?php

function add(int $a, int $b) {
    return $a + $b;
}

var_dump(add(1, 2)); // Outputs "int(3)"

Par défaut, PHP tentera de convertir tout argument fourni pour correspondre à son indice de type. Changer l'appel à add(1.5, 2) donne exactement le même résultat, puisque le float 1.5 été converti en int par PHP.

Pour arrêter ce comportement, il faut ajouter declare(strict_types=1); en haut de chaque fichier source PHP qui le nécessite.

<?php

declare(strict_types=1);

function add(int $a, int $b) {
    return $a + $b;
}

var_dump(add(1.5, 2));

Le script ci-dessus génère désormais une erreur fatale:

Erreur fatale: UnCaught TypeError: l'argument 1 transmis à add () doit être du type entier, float donné

Une exception: types spéciaux

Certaines fonctions PHP peuvent renvoyer une valeur de type resource . Comme il ne s'agit pas d'un type scalaire, mais d'un type spécial, il n'est pas possible de le saisir.

Par exemple, curl_init() renverra une resource , ainsi que fopen() . Bien sûr, ces deux ressources ne sont pas compatibles entre elles. À cause de cela, PHP 7 lancera toujours le TypeError suivant lorsque vous tapez explicitement une resource conseil:

TypeError: l'argument 1 transmis à sample () doit être une instance de ressource, ressource donnée

Tapez des objets génériques

Étant donné que les objets PHP n'héritent d'aucune classe de base (y compris stdClass ), il n'y a pas de prise en charge pour le type indiquant un type d'objet générique.

Par exemple, le ci-dessous ne fonctionnera pas.

<?php

function doSomething(object $obj) {
    return $obj;
}

class ClassOne {}
class ClassTwo {}

$classOne= new ClassOne();
$classTwo= new ClassTwo();

doSomething($classOne);
doSomething($classTwo);

Et va jeter une erreur fatale:

Erreur fatale: UnCaught TypeError: l'argument 1 transmis à doSomething () doit être une instance d'objet, instance de OperationOne donnée

Une solution à ce problème consiste à déclarer une interface dégénérée qui ne définit aucune méthode et à laquelle tous vos objets implémentent cette interface.

<?php

interface Object {}

function doSomething(Object $obj) {
    return $obj;
}

class ClassOne implements Object {}
class ClassTwo implements Object {}

$classOne = new ClassOne();
$classTwo = new ClassTwo();

doSomething($classOne);
doSomething($classTwo);

Tapez les classes et les interfaces de conseil

L'indication de type pour les classes et les interfaces a été ajoutée en PHP 5.

Indice de type de classe

<?php

class Student
{
    public $name = 'Chris';
}

class School
{
    public $name = 'University of Edinburgh';
}

function enroll(Student $student, School $school)
{
    echo $student->name . ' is being enrolled at ' . $school->name;
}

$student = new Student();
$school = new School();

enroll($student, $school);

Le script ci-dessus affiche:

Chris est inscrit à l'Université d'Edimbourg

Indice de type d'interface

<?php

interface Enrollable {};
interface Attendable {};

class Chris implements Enrollable
{
    public $name = 'Chris';
}

class UniversityOfEdinburgh implements Attendable
{
    public $name = 'University of Edinburgh';
}

function enroll(Enrollable $enrollee, Attendable $premises)
{
    echo $enrollee->name . ' is being enrolled at ' . $premises->name;
}

$chris = new Chris();
$edinburgh = new UniversityOfEdinburgh();

enroll($chris, $edinburgh);

L'exemple ci-dessus produit le même résultat que précédemment:

Chris est inscrit à l'Université d'Edimbourg

Indices de type auto

Le mot-clé self peut être utilisé comme indicateur de type pour indiquer que la valeur doit être une instance de la classe qui déclare la méthode.

Type Indication Aucun retour (annulé)

En PHP 7.1, le type de retour void été ajouté. Bien que PHP n'ait pas de valeur void réelle, il est généralement compris dans les langages de programmation qu’une fonction qui ne retourne rien renvoie un void . Cela ne devrait pas être confondu avec le retour de null , car null est une valeur qui peut être retournée.

function lacks_return(): void {
    // valid
}

Notez que si vous déclarez un retour void , vous ne pouvez retourner aucune valeur ou vous obtiendrez une erreur fatale:

function should_return_nothing(): void {
    return null; // Fatal error: A void function must not return a value
}

Cependant, l'utilisation de return pour quitter la fonction est valide:

function returns_nothing(): void {
    return; // valid
}

Astuces de type nullable

Paramètres

L'indication de type nullable a été ajoutée à PHP 7.1 en utilisant le ? opérateur avant l'indication de type.

function f(?string $a) {}
function g(string $a) {}

f(null); // valid
g(null); // TypeError: Argument 1 passed to g() must be of the type string, null given

Avant PHP 7.1, si un paramètre a un indice de type, il doit déclarer une valeur par défaut null pour accepter les valeurs nulles.

function f(string $a = null) {}
function g(string $a) {}

f(null); // valid
g(null); // TypeError: Argument 1 passed to g() must be of the type string, null given

Valeurs de retour

En PHP 7.0, les fonctions avec un type de retour ne doivent pas renvoyer null.

En PHP 7.1, les fonctions peuvent déclarer un indice de type de retour nullable. Cependant, la fonction doit toujours retourner la valeur null, pas void (instructions de retour no / empty).

function f() : ?string {
    return null;
}

function g() : ?string {}
function h() : ?string {}

f(); // OK
g(); // TypeError: Return value of g() must be of the type string or null, none returned
h(); // TypeError: Return value of h() must be of the type string or null, none returned