PHP
Geben Sie Hinweis ein

Syntax

• Funktion f (ClassName $ param) {}
• Funktion f (bool $ param) {}
• Funktion f (int $ param) {}
• Funktion f (float $ param) {}
• Funktion f (String $ param) {}
• Funktion f (selbst $ param) {}
• Funktion f (aufrufbare $ param) {}
• Funktion f (Array $ param) {}
• Funktion f (? type_name $ param) {}
• Funktion f (): Typname {}
• Funktion f (): ungültig {}
• Funktion f ():? type_name {}

Bemerkungen

Geben Sie Skalar-Typen, Arrays und Callables an

Unterstützung für Typen Array - Parameter Hinting (und Rückgabewerte nach PHP 7.1) wurde in PHP 5.1 mit dem Schlüsselwort hinzugefügt array . Alle Arrays mit beliebigen Dimensionen und Typen sowie leere Arrays sind gültige Werte.

In PHP 5.4 wurde die Unterstützung für Typhinweis-Callables hinzugefügt. Jeder Wert, der is_callable() ist, gilt für callable Parameter und Rückgabewerte, dh Closure Objekte, Funktionsnamenszeichenfolgen und array(class_name|object, method_name) .

Wenn im Funktionsnamen ein Tippfehler auftritt, der nicht is_callable() , wird eine weniger offensichtliche Fehlermeldung angezeigt:

Schwerwiegender Fehler: Nicht abgerufener TypeError: Argument 1, das an foo () übergeben wird, muss vom aufrufbaren Typ sein, String / Array

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

Nicht statische Methoden können auch im statischen Format als Callables übergeben werden. Dies führt zu einer Warnung vor Ablehnung und einem E_STRICT-Fehler in PHP 7 bzw. 5.

Die Sichtbarkeit der Methode wird berücksichtigt. Wenn der Kontext der Methode mit dem callable Parameter keinen Zugriff auf das bereitgestellte aufrufbare Element hat, endet die Methode, als wäre die Methode nicht vorhanden.

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

Ausgabe:

Schwerwiegender Fehler: Nicht abgerufener TypeError: Argument 1, das an r () übergeben wird, muss aufrufbar sein, Array angegeben

Unterstützung für Typhinweis-Skalartypen wurde in PHP 7 hinzugefügt. Dies bedeutet, dass Typanweisungsunterstützung für boolean s, integer s, float s und string s zur Verfügung steht.

<?php

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

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

Standardmäßig versucht PHP, jedes angegebene Argument in seinen Typhinweis umzuwandeln. Wenn Sie den Aufruf in add(1.5, 2) ändern, erhalten Sie exakt dieselbe Ausgabe, da der Float 1.5 von PHP in int wurde.

Um dieses Verhalten zu beenden, müssen Sie declare(strict_types=1); hinzufügen declare(strict_types=1); an der Spitze jeder PHP-Quelldatei, die es benötigt.

<?php

declare(strict_types=1);

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

var_dump(add(1.5, 2));

Das obige Skript erzeugt jetzt einen schwerwiegenden Fehler:

Schwerwiegender Fehler: Nicht abgerufener TypeError: Argument 1, das an add () übergeben wurde, muss den Typ integer haben, gegebenes Float

Eine Ausnahme: Sondertypen

Einige PHP-Funktionen geben möglicherweise einen Wert der resource . Da es sich nicht um einen skalaren Typ handelt, sondern um einen speziellen Typ, ist es nicht möglich, einen Hinweis einzugeben.

Als Beispiel gibt curl_init() eine resource sowie fopen() . Natürlich sind diese beiden Ressourcen nicht miteinander kompatibel. Aus diesem Grund wirft PHP 7 immer den folgenden TypeError ab, wenn die resource explizit als Typ bezeichnet wird:

TypeError: Argument 1, das an sample () übergeben wurde, muss eine Instanz der Ressource sein

Geben Sie generische Objekte ein

Da PHP-Objekte von keiner Basisklasse (einschließlich stdClass ) erben, wird der stdClass auf einen generischen Objekttyp nicht unterstützt.

Zum Beispiel funktioniert das unten nicht.

<?php

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

class ClassOne {}
class ClassTwo {}

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

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

Und wird einen schwerwiegenden Fehler werfen:

Schwerwiegender Fehler: Nicht erfasstes TypeError: Argument 1, das an doSomething () übergeben wird, muss eine Instanz eines Objekts sein, eine Instanz von OperationOne

Um dieses Problem zu umgehen, deklarieren Sie eine entartete Schnittstelle, die keine Methoden definiert, und alle Objekte müssen diese Schnittstelle implementieren.

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

Geben Sie Hinting-Klassen und Schnittstellen ein

In PHP 5 wurden Typhinweise für Klassen und Schnittstellen hinzugefügt.

Hinweis zum Klassentyp

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

Das obige Skript gibt aus:

Chris wird an der University of Edinburgh eingeschrieben

Schnittstellentyp-Hinweis

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

Das obige Beispiel gibt das gleiche wie zuvor aus:

Chris wird an der University of Edinburgh eingeschrieben

Hinweise zur Eigenart

Das Schlüsselwort self kann als Typhinweis verwendet werden, um anzuzeigen, dass der Wert eine Instanz der Klasse sein muss, die die Methode deklariert.

Typ Hinting No Return (Void)

In PHP 7.1 wurde der Rückgabetyp void hinzugefügt. PHP hat zwar keinen tatsächlichen void Wert, es wird jedoch in allen Programmiersprachen allgemein verstanden, dass eine Funktion, die nichts zurückgibt, void . Dies sollte nicht mit der Rückgabe von null verwechselt werden, da null ein Wert ist, der zurückgegeben werden kann.

function lacks_return(): void {
    // valid
}

Wenn Sie eine void Rückgabe deklarieren, können Sie keine Werte zurückgeben, da sonst ein schwerwiegender Fehler angezeigt wird:

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

Die Verwendung von return zum Beenden der Funktion ist jedoch gültig:

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

Nullwert-Typhinweise

Parameter

In PHP 7.1 wurde ein Null-Typ-Hinweis mit dem ? Operator vor dem Typhinweis.

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

Wenn ein Parameter vor PHP 7.1 einen Typhinweis hat, muss er einen Standardwert null , um Nullwerte zu akzeptieren.

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

Rückgabewerte

In PHP 7.0 dürfen Funktionen mit einem Rückgabetyp nicht null zurückgeben.

In PHP 7.1 können Funktionen einen nullwertfähigen Rückgabewerthinweis deklarieren. Die Funktion muss jedoch immer null und nicht void zurückgeben (keine Rückgabeanweisungen).

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