Tipi singoli

mixed è equivalente al tipo union objectresourcearraystring intfloatboolnull . Disponibile a partire da PHP 8.0.0.

<?php
class C {}
class D extends C {}

// Questa non estende C.
class E {}

function f(C $c) {
    echo get_class($c)."\n";
}

f(new C);
f(new D);
f(new E);
?>

    

<?php
interface I { public function f(); }
class C implements I { public function f() {} }

// Questa non implementa I.
class E {}

function f(I $i) {
    echo get_class($i)."\n";
}

f(new C);
f(new E);
?>

    

<?php
function sum($a, $b): float {
    return $a + $b;
}

// Notare che verrà restituito un float.
var_dump(sum(1, 2));
?>

    

<?php
class C {}

function getC(): C {
    return new C;
}

var_dump(getC());
?>

    

Tipo nullable

A partire da PHP 7.1.0, le dichiarazioni di tipo possono essere contrassegnate come nullable anteponendo al nome del tipo un punto interrogativo (?). Ciò significa che il valore può essere del tipo specificato o null.

Dichiarazione del tipo di argomento nullable <?php class C {} function f(?C $c) { var_dump($c); } f(new C); f(null); ?> Example outputs object(C)#1 (0) { } NULL Dichiarazione del tipo restituito nullable <?php function get_item(): ?string { if (isset($_GET['item'])) { return $_GET['item']; } else { return null; } } ?>

Tipi compositi

È possibile combinare tipi semplici in tipi compositi. PHP consente di combinare i tipi nei seguenti modi:

• Union di tipi semplici. A partire da PHP 8.0.0.
• Intersezione di tipi di classi (interfacce e nomi di classi). A partire da PHP 8.1.0.

Non è possibile combinare i tipi di intersezione con i tipi union.

Una dichiarazione di tipo union accetta valori di più tipi semplici diversi, anziché uno solo. I tipi union vengono specificati utilizzando la sintassi T1|T2|.... I tipi union sono disponibili a partire da PHP 8.0.0.

Il tipo null è supportato come parte delle union, in modo tale che T1|T2|null possa essere utilizzato per creare una union nullable. La notazione ?T esistente è considerata una scorciatoia per il caso comune di T|null.

null non può essere utilizzato come tipo autonomo.

Il tipo letterale false è supportato come parte delle union ed è incluso poiché per ragioni storiche molte funzioni interne restituiscono false invece di null per gli errori. Un classico esempio di tale funzione è strpos.

false non può essere utilizzato come tipo autonomo (incluso il tipo autonomo nullable). Pertanto, false, false|null e ?false non sono consentiti.

Il tipo letterale true non esiste.

Una dichiarazione di tipo intersezione accetta valori che soddisfano più dichiarazioni di tipo classe, anziché una singola. I tipi intersezione sono specificati utilizzando la sintassi T1AmpT2Amp.... I tipi intersezione sono disponibili a partire da PHP 8.1.0.

Per rilevare semplici bug nelle dichiarazioni di tipo composito, i tipi ridondanti che possono essere rilevati senza eseguire il caricamento della classe risulteranno in un errore in fase di compilazione. Ciò comprende: Ogni tipo risolto dal nome può verificarsi solo una volta. Tipi come int|string|INT o CountableAmpTraversableAmpCOUNTABLE generano un errore. L'utilizzo di mixed genera un errore. Per i tipi union: Se viene usato bool, false non può essere utilizzato in aggiunta. Se viene usato object, i tipi di classe non possono essere utilizzati in aggiunta. Se viene usato iterable, array e Traversable non possono essere utilizzati in aggiunta. Per i tipi intersezione: L'utilizzo di un tipo che non è un tipo di classe genera un errore. L'utilizzo di self, parent o static genera un errore.

Ad esempio, se A e B sono alias di classe, A|B rimane un tipo di union legale, anche se potrebbe essere ridotto a A o B. Allo stesso modo, se la classe B extends A {}, anche A|B è un tipo di union legale, anche se potrebbe essere ridotta solo a A. <?php function foo(): int|INT {} // Non consentito function foo(): bool|false {} // Non consentito function foo(): int&Traversable {} // Non consentito function foo(): self&Traversable {} // Non consentito use A as B; function foo(): A|B {} // Non consentito ("use" fa parte della risoluzione dei nomi) function foo(): A&B {} // Non consentito ("use" fa parte della risoluzione dei nomi) class_alias('X', 'Y'); function foo(): X|Y {} // Consentito (la ridondanza è nota solo in fase di esecuzione) function foo(): X&Y {} // Consentito (la ridondanza è nota solo in fase di esecuzione) ?>

Tipi di solo ritorno

void è un tipo di ritorno che indica che la funzione non restituisce un valore. Pertanto non può essere parte di una dichiarazione di tipo union. Disponibile da PHP 7.1.0.

never è un tipo di ritorno che indica che la funzione non ha un ritorno. Ciò significa che chiama exit, genera un'eccezione o è un ciclo infinito. Pertanto non può essere parte di una dichiarazione di tipo union. Disponibile a partire da PHP 8.1.0.

never è, nel gergo della teoria dei tipi, il tipo inferiore. Significa che è il sottotipo di ogni altro tipo e può sostituire qualsiasi altro tipo di ritorno durante l'ereditarietà.

Il valore deve essere un'Instanceof della stessa classe di quella in cui è chiamato il metodo. Disponibile da PHP 8.0.0.

Tipizzazione strict

Per impostazione predefinita, PHP costringerà i valori del tipo sbagliato nella dichiarazione del tipo scalare previsto, se possibile. Ad esempio, una funzione a cui viene assegnato un int per un parametro che prevede una string otterrà una variabile di tipo string.

È possibile abilitare la modalità strict per file. In modalità strict, sarà accettato solo un valore corrispondente esattamente alla dichiarazione del tipo, altrimenti verrà lanciato un TypeError. L'unica eccezione a questa regola è che un valore int passerà una dichiarazione di tipo float.

Per abilitare la modalità rigorosa, il Declare viene utilizzato con la dichiarazione strict_types:

<?php
declare(strict_types=1);

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

var_dump(sum(1, 2));
var_dump(sum(1.5, 2.5));
?>

   

<?php
function sum(int $a, int $b) {
    return $a + $b;
}

var_dump(sum(1, 2));

// Questi verranno convertiti in numeri interi: nota l'output qui sotto!
var_dump(sum(1.5, 2.5));
?>

   

<?php
declare(strict_types=1);

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

var_dump(sum(1, 2));
var_dump(sum(1, 2.5));
?>

   

Tipizzazione coercitiva con tipi union

Quando strict_types non è abilitato, le dichiarazioni di tipo scalare sono soggette a limitate coercizioni di tipo implicito. Se il tipo esatto del valore non fa parte della union, il tipo di destinazione viene scelto nel seguente ordine di preferenza: int float string bool Se il tipo esiste nella union e il valore può essere forzato al tipo sotto la semantica di controllo del tipo esistente di PHP, viene scelto il tipo. Altrimenti viene provato il tipo successivo.

In via eccezionale, se il valore è una stringa e sia int che float fanno parte della union, il tipo preferito è determinato dalla semantica “stringa numerica” esistente. Ad esempio, per "42" viene scelto int, mentre per "42.0" viene scelto float.

<?php
// int|string
42    --> 42          // tipo esatto
"42"  --> "42"        // tipo esatto
new ObjectWithToString --> "Risultato di __toString()"
                      // oggetto mai compatibile con int, ripiega su string
42.0  --> 42          // float compatibile con int
42.1  --> 42          // float compatibile con int
1e100 --> "1.0E+100"  // float troppo grande per il tipo int, ripiega su string
INF   --> "INF"       // float troppo grande per il tipo int, ripiega su string
true  --> 1           // bool compatibile con int
[]    --> TypeError   // array non compatibile con int o string

// int|float|bool
"45"    --> 45        // stringa numerica intera
"45.0"  --> 45.0      // stringa numerica float

"45X"   --> true      // non una stringa numerica, ripiega su bool
""      --> false     // non una stringa numerica, ripiega su bool
"X"     --> true      // non una stringa numerica, ripiega su bool
[]      --> TypeError // array non compatibile con int, float o bool
?>

   

Misc

<?php
function array_baz(array &$param)
{
    $param = 1;
}
$var = [];
array_baz($var);
var_dump($var);
array_baz($var);
?>

    

<?php
declare(strict_types=1);

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

try {
    var_dump(sum(1, 2));
    var_dump(sum(1.5, 2.5));
} catch (TypeError $e) {
    echo 'Error: ', $e->getMessage();
}
?>