PHP7 déclare les types scalaires et explique une vérification de type forte

PHP7 est sorti dès 2015 et de plus en plus de personnes l'utilisent. Dans cet article, nous allons parler de la façon dont PHP7 déclare les types scalaires et de la façon dont PHP7 effectue une vérification de type forte. je peux jeter un oeil!

Déclaration de type scalaire

PHP prend en charge la déclaration de type de paramètre de classe et d'interface depuis PHP5.0, PHP5.1 prend en charge les tableaux et PHP5.4 prend en charge l'appel. Ces déclarations de type permettent à PHP de transmettre les paramètres corrects lors de l'exécution, ce qui rend la signature de fonction plus informative.

À partir de PHP7, int, float, string et bool seront reconnus comme des déclarations de type et peuvent être utilisés pour les types de valeur de retour de fonction et les déclarations de type de paramètre

<?php
function sum(int $a,int $b):string {
return $a+$b;
}
var_dump(sum(1,2));

Le code ci-dessus s'exécute normalement
Le résultat est string(1) "3". En mode de vérification de type faible, si le paramètre ne correspond pas au type déclaré, il sera converti selon les règles PHP

PHP7.1 ajoute une déclaration pour les types nullables et ajoute void est utilisé comme type de valeur de retour de fonction. En mode de vérification de type fort, une fonction définie comme type de retour void ne peut pas avoir de valeur de retour, même si elle renvoie null :

declare(strict_types=1);
function returns_one(): void {
return 1; // Fatal error: A void function must not return a value
}
function returns_null(): void {
return null; // Fatal error: A void function must not return a value
}

De plus, void n'est applicable qu'aux types de retour. Il ne peut pas être utilisé pour la déclaration de type de paramètre, sinon une erreur sera déclenchée :

function foobar(void $foo) { 
// Fatal error: void cannot be used as a parameter type
}

Déclaration de type Nullable

Type Nullable. est principalement utilisé pour la déclaration du type de paramètre et la déclaration de la valeur de retour de la fonction. Les deux formes principales de

sont les suivantes :

function answer(): ?int{
return null; //ok
}function answer(): ?int{
return 42; // ok
}
function say(?string $msg) {
if ($msg) {
echo $msg;
}
}

Il est facile de comprendre à partir de l'exemple. Ce que cela signifie est d'indiquer le type de paramètre de fonction. ou renvoie une valeur sous la forme de ? Soit le type spécifié, soit null.

Cette méthode peut également être utilisée pour la définition de fonctions d'interface :

interface Fooable {
function foo(?Fooable $f);
}

Mais il y a une chose à noter : si la fonction elle-même définit le type de paramètre et n'a pas de valeur par défaut, même s'il est nullable, il ne peut pas être omis, sinon une erreur sera déclenchée.

est la suivante :

function foo_nullable(?Bar $bar) {}foo_nullable(new Bar); // 可行
foo_nullable(null); // 可行
foo_nullable(); // 不可行

Mais si le paramètre de la fonction ci-dessus est défini sous la forme ?Bar $bar = null, la troisième façon de l'écriture est également réalisable. Étant donné que = null est en fait équivalent à un sur-ensemble de ?, null peut être défini comme valeur par défaut pour les paramètres de types nullables.

La déclaration du type de retour dans une fonction de classe ne peut pas être surchargée par une sous-classe, sinon une erreur sera déclenchée :

class Foo
{
public function bar(): void {
}
}class Foobar extends Foo
{
public function bar(): array { // Fatal error: Declaration of Foobar::bar() must be compatible with Foo::bar(): void
}
}

Mode de vérification stricte
directive strict_types/declare()

Par défaut, tous les fichiers PHP sont en mode de vérification de type faible. La nouvelle directive declare spécifie la valeur de strict_types (1 ou 0). 1 indique un mode de vérification de type strict, qui s'applique aux appels de fonction et aux instructions return ; 0 indique un mode de vérification de type faible.

declare(strict_types=1) doit être la première instruction du fichier. Si cette instruction apparaît ailleurs dans le fichier, une erreur de compilation sera générée et le mode bloc est explicitement interdit.

Semblable à la directive encoding, mais différente de la directive ticks, la directive strict_types n'affecte que le fichier spécifié et n'affectera pas les autres fichiers qu'il inclut (via include, etc.). Cette directive est compilée au moment de l'exécution et ne peut pas être modifiée. La façon dont cela fonctionne est de définir un indicateur dans l'opcode afin que les appels de fonction et les vérifications de type de retour soient conformes aux contraintes de type.

<?php
declare(strict_types=1);
function sum(int $a,int $b):string {
return $a+$b;
}
var_dump(sum(1,2));

Le code ci-dessus n'est pas conforme à la valeur de retour de la fonction déclaration de type, et une TypeError sera levée

<?php
declare(strict_types=1);
function sum(string $a,string $b):string {
return $a+$b;
}
var_dump(sum(1,2));

Le code ci-dessus n'est pas conforme à la déclaration de type du paramètre de la fonction, générera également une erreur

Il y a une exception, la conversion de type large permet à int de devenir float, c'est-à-dire si le paramètre est déclaré comme type float, il peut toujours accepter les paramètres int.

<?php
declare(strict_types=1);
function sum(int $a,int $b):float {
return $a+$b;
}
var_dump(sum(1,2));

Le code ci-dessus s'exécute normalement

Dans ce scénario, nous passons un paramètre int à la fonction définie pour accepter float, et ce paramètre sera converti en float. Les conversions autres que celles-ci ne sont pas autorisées.

Recommandations associées :

Introduction aux performances de la version PHP7.2

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!