PHP
Digita suggerimento

Sintassi

• funzione f (ClassName $ param) {}
• funzione f (bool $ param) {}
• funzione f (int $ param) {}
• funzione f (float $ param) {}
• funzione f (stringa $ param) {}
• funzione f (self $ param) {}
• funzione f (callable $ param) {}
• funzione f (array $ param) {}
• funzione f (? type_name $ param) {}
• function f (): type_name {}
• function f (): void {}
• funzione f ():? type_name {}

Osservazioni

Digitare suggerimenti su tipi scalari, array e callables

Il supporto per i parametri del tipo hinting array (e valori restituiti dopo PHP 7.1) è stato aggiunto in PHP 5.1 con la array parole chiave. Qualsiasi array di qualsiasi dimensione e tipo, così come array vuoti, sono valori validi.

Il supporto per hinting callables è stato aggiunto in PHP 5.4. Qualsiasi valore is_callable() è valida per i parametri ei valori restituiti accennato callable , cioè Closure oggetti, stringhe di nome e funzione array(class_name|object, method_name) .

Se si verifica un errore di battitura nel nome della funzione tale da non essere is_callable() , verrà visualizzato un messaggio di errore meno ovvio:

Errore irreversibile: Uncaught TypeError: l'argomento 1 passato a foo () deve essere del tipo callable, stringa / matrice dati

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

I metodi non statici possono anche essere passati come callebles in formato statico, con conseguente avviso di deprecazione e errore E_STRICT di livello in PHP 7 e 5 rispettivamente.

La visibilità del metodo viene presa in considerazione. Se il contesto del metodo con il parametro callable non ha accesso al callable fornito, finirà come se il metodo non esistesse.

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

Produzione:

Errore irreversibile: Uncaught TypeError: l'argomento 1 passato a r () deve essere chiamabile, matrice fornita

Il supporto per tipi scalari di tipo hint è stato aggiunto in PHP 7. Ciò significa che otteniamo il supporto del tipo hinting per i integer boolean , integer , float e string s.

<?php

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

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

Per impostazione predefinita, PHP tenterà di eseguire il cast di qualsiasi argomento fornito in modo che corrisponda al suo suggerimento tipo. Cambiare la chiamata da add(1.5, 2) dà esattamente lo stesso risultato, dal momento che il float 1.5 stato lanciato su int da PHP.

Per interrompere questo comportamento, è necessario aggiungere declare(strict_types=1); all'inizio di ogni file sorgente PHP che lo richiede.

<?php

declare(strict_types=1);

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

var_dump(add(1.5, 2));

Lo script sopra ora produce un errore fatale:

Errore irreversibile: Uncaught TypeError: l'argomento 1 passato a add () deve essere di tipo intero, float dato

Un'eccezione: tipi speciali

Alcune funzioni PHP possono restituire un valore di tipo resource . Poiché non si tratta di un tipo scalare, ma di un tipo speciale, non è possibile digitare il suggerimento.

Ad esempio, curl_init() restituirà una resource , come pure fopen() . Naturalmente, queste due risorse non sono compatibili l'una con l'altra. Per questo motivo, PHP 7 invierà sempre il seguente TypeError quando si digita esplicitamente la resource hint:

TypeError: l'argomento 1 passato a sample () deve essere un'istanza di risorsa, risorsa fornita

Digita suggerimenti sugli oggetti generici

Poiché gli oggetti PHP non ereditano da alcuna classe base (incluso stdClass ), non esiste alcun supporto per il tipo che suggerisce un tipo di oggetto generico.

Ad esempio, il sotto non funzionerà.

<?php

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

class ClassOne {}
class ClassTwo {}

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

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

E genererà un errore fatale:

Errore irreversibile: Uncaught TypeError: l'argomento 1 passato a doSomething () deve essere un'istanza di oggetto, istanza di OperationOne fornita

Una soluzione alternativa consiste nel dichiarare un'interfaccia degenerata che non definisce metodi e che tutti gli oggetti implementano questa interfaccia.

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

Digitare classi e interfacce di suggerimento

Il tipo di suggerimento per le classi e le interfacce è stato aggiunto in PHP 5.

Suggerimento di 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);

Lo script sopra riportato produce:

Chris è iscritto all'università di Edimburgo

Tipo di interfaccia suggerimento

<?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'esempio sopra riportato è lo stesso di prima:

Chris è iscritto all'università di Edimburgo

Suggerimenti di tipo auto

La parola chiave self può essere utilizzata come suggerimento tipo per indicare che il valore deve essere un'istanza della classe che dichiara il metodo.

Type Hinting No Return (Void)

In PHP 7.1, è stato aggiunto il tipo di reso void . Mentre PHP non ha un valore reale void , è generalmente inteso tra i linguaggi di programmazione che una funzione che restituisce nulla restituisce void . Questo non dovrebbe essere confuso con la restituzione di null , poiché null è un valore che può essere restituito.

function lacks_return(): void {
    // valid
}

Tieni presente che se dichiari un void , non puoi restituire alcun valore o otterrai un errore fatale:

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

Tuttavia, usando return to exit la funzione è valida:

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

Suggerimenti tipo Nullable

parametri

Il suggerimento di tipo Nullable è stato aggiunto in PHP 7.1 usando il ? operatore prima del suggerimento sul tipo.

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

Prima di PHP 7.1, se un parametro ha un suggerimento tipo, deve dichiarare un valore predefinito null per accettare valori nulli.

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

Valori di ritorno

In PHP 7.0, le funzioni con un tipo restituito non devono restituire null.

In PHP 7.1, le funzioni possono dichiarare un suggerimento di tipo nullable return. Tuttavia, la funzione deve ancora restituire null, non void (no / empty return statements).

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