Quelles sont les contraintes de type php ? Introduction et utilisation des contraintes de type php

La contrainte de type signifie que lors de la définition d'une variable, son type doit être spécifié et la variable ne peut stocker des données de ce type qu'à l'avenir. Dans cet article, je vais vous présenter les contraintes et l'utilisation du type PHP.

Introduction aux contraintes de type PHP

PHP est un langage faiblement typé. Sa particularité est qu'il n'est pas nécessaire de spécifier un type pour une variable, et n'importe quel type peut être stocké par la suite, bien sûr, c'est aussi l'un des points clés pour un développement rapide avec PHP. Mais depuis PHP5, nous pouvons utiliser des contraintes de type dans les paramètres de fonction (méthode).

Les paramètres de la fonction peuvent être spécifiés dans la plage suivante :

1. Il doit s'agir d'un objet (précisez le nom de la classe dans le prototype de la fonction) ; >2. Interface ;

3. Tableau (à partir de PHP 5.1)

4.

5. Si vous utilisez NULL comme valeur par défaut du paramètre, vous pouvez toujours utiliser NULL comme paramètre réel lors de l'appel de la fonction.

6. Si une classe ou une interface spécifie une contrainte de type, toutes ses sous-classes ou implémentations le font également.

Remarque

 : Avant PHP7, les contraintes de type ne pouvaient pas être utilisées pour les types scalaires tels que int ou string. Les traits ne sont pas non plus autorisés.

Utilisation des contraintes de type PHP :

Ce qui suit est l'exemple officiel :

Paramètres et définitions des appels de fonction Quand les types de paramètres sont incohérents, une erreur fatale capturable sera générée.

<?php
//如下面的类
class MyClass
{
    /**
     * 测试函数
     * 第一个参数必须为 OtherClass 类的一个对象
     */
    public function test(OtherClass $otherclass) {
        echo $otherclass->var;
    }


    /**
     * 另一个测试函数
     * 第一个参数必须为数组 
     */
    public function test_array(array $input_array) {
        print_r($input_array);
    }
}

    /**
     * 第一个参数必须为递归类型
     */
    public function test_interface(Traversable $iterator) {
        echo get_class($iterator);
    }
    
    /**
     * 第一个参数必须为回调类型
     */
    public function test_callable(callable $callback, $data) {
        call_user_func($callback, $data);
    }
}

// OtherClass 类定义
class OtherClass {
    public $var = 'Hello World';
}
?>

Les contraintes de type ne sont pas seulement utilisées dans les fonctions membres de la classe, mais également dans les fonctions :

<?php
// 两个类的对象
$myclass = new MyClass;
$otherclass = new OtherClass;

// 致命错误：第一个参数必须是 OtherClass 类的一个对象
$myclass->test('hello');

// 致命错误：第一个参数必须为 OtherClass 类的一个实例
$foo = new stdClass;
$myclass->test($foo);

// 致命错误：第一个参数不能为 null
$myclass->test(null);

// 正确：输出 Hello World 
$myclass->test($otherclass);

// 致命错误：第一个参数必须为数组
$myclass->test_array('a string');

// 正确：输出数组
$myclass->test_array(array('a', 'b', 'c'));

// 正确：输出 ArrayObject
$myclass->test_interface(new ArrayObject(array()));

// 正确：输出 int(1)
$myclass->test_callable('var_dump', 1);
?>

Les contraintes de type autorisent les valeurs NULL :

<?php
// 如下面的类
class MyClass {
    public $var = &#39;Hello World&#39;;
}

/**
 * 测试函数
 * 第一个参数必须是 MyClass 类的一个对象
 */
function MyFunction (MyClass $foo) {
    echo $foo->var;
}

// 正确
$myclass = new MyClass;
MyFunction($myclass);
?>

<?php

/* 接受 NULL 值 */
function test(stdClass $obj = NULL) {

}

test(NULL);
test(new stdClass);

?>

PHP7

Déclaration de type scalaire (PHP 7)

La déclaration de type scalaire a deux modes : obligatoire (par défaut) et mode strict.

Les paramètres de type suivants peuvent désormais être utilisés (que ce soit en mode forcé ou en mode strict) :

1 String (string),

Integer (int),

.

3. Nombre à virgule flottante (float),

4. Valeur booléenne (bool).

Ils étendent d'autres types introduits dans PHP5 : noms de classes, interfaces, tableaux et types de rappel.

L'exemple ci-dessus affichera : int(9)

<?php
// 强制模式
function sumOfInts(int ...$ints)
{
     return array_sum($ints);
}
 
var_dump(sumOfInts(2, '3', 4.1));

Pour utiliser le mode strict, une directive de déclaration déclarer doit être placée en haut du fichier. Cela signifie que les scalaires sont strictement déclarés configurables sur la base d'un fichier. Cette directive affecte non seulement la déclaration de type des paramètres, mais affecte également la déclaration de valeur de retour des fonctions.

Articles connexes recommandés :

Introduction aux contraintes de type en PHP, introduction aux contraintes de type PHP

Partage d'idées de code pour les contraintes de type en PHP

Partage d'idées de code pour les contraintes de type en PHP

Comment utiliser les contraintes de type pour limiter les types de fonctions php

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!