PHP
Digita suggerimento
Ricerca…
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
Le dichiarazioni di tipo hinting o type sono una pratica di programmazione difensiva che garantisce che i parametri di una funzione siano di un tipo specificato. Ciò è particolarmente utile quando si digita il suggerimento per un'interfaccia perché consente alla funzione di garantire che un parametro fornito abbia gli stessi metodi richiesti nell'interfaccia.
Il passaggio del tipo errato a una funzione di tipo suggerito causerà un errore irreversibile:
Errore irreversibile: Uncaught TypeError: l'argomento X passato a foo () deve essere del tipo RequiredType , ProvidedType dato
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