PHP5 type constraints study notes_PHP tutorial-PHP Tutorial-php.cn

php is a weakly typed programming language. In a PHP program, the data type of a variable can automatically change as its value changes, and PHP will not perform mandatory checks or constraints on the data type of the variable

We can refer to the following simple code example:

The code is as follows

Copy code

代码如下

复制代码

class Person {

}

$a = 1; //此时,$a为整数类型型(Integer)
var_dump($a);
$a = 1.0; //此时,$a为浮点类型(Float)
var_dump($a);
$a = 'CodePlayer'; //此时,$a为字符串类型(String)
var_dump($a);
$a = array('CodePlayer' => 'http://www.bKjia.c0m'); //此时,$a为数组类型(Array)
    var_dump($a);
    $a = new Person(); //此时,$a为Person对象类型(Object)
    var_dump($a);
    $a = mysql_connect('localhost', 'username', 'password');    //此时,$a为资源类型(Resource)
    var_dump($a);
    ?>

class Person {

}

$a = 1; //At this time, $a is an integer type (Integer)

var_dump($a);

代码如下

复制代码

class Person {
public $name = 'CodePlayer';
public $age = 3;
}

function sayHi($person){
echo "Hello! My name is $person->name. I'm $person->age years old.";
}

    $p = '张三';
    sayHi($p); //不是期望的Person对象类型，将出现Notice级别错误信息，程序仍然继续运行
    echo 'Suffix'; //仍然会输出该文本信息
    ?>

$a = 1.0; //At this time, $a is a floating point type (Float) var_dump($a); $a = 'CodePlayer'; //At this time, $a is a string type (String) var_dump($a); $a = array('CodePlayer' => 'http://www.bKjia.c0m'); //At this time, $a is an array type (Array) var_dump($a); $a = new Person(); //At this time, $a is the Person object type (Object) var_dump($a); $a = mysql_connect('localhost', 'username', 'password'); //At this time, $a is the resource type (Resource) var_dump($a); ?> The corresponding operation effect is shown in the figure below: The characteristics of PHP's weak data types make PHP easy and flexible to use. However, this is also the Sword of Damocles. It is precisely because of the characteristics of PHP's weak data types that developers need to always pay attention to changes in variable data types when writing PHP program code, especially when variables are passed as parameters of functions. After all, most function parameters expect only certain data types. For example, in the following example, the function sayHi() expects to receive a parameter type of Person object type. However, since PHP is not a strongly typed language and does not force checking the type of variables, we can pass any arbitrary value to the function. type parameters, causing program errors or logic exceptions.

The code is as follows

Copy code

class Person {<🎜> public $name = 'CodePlayer';<🎜> public $age = 3;<🎜> }<🎜> <🎜> function sayHi($person){<🎜> echo "Hello! My name is $person->name. I'm $person->age years old."; } $p = 'Zhang San'; SayHi($p); //It is not the expected Person object type, a Notice level error message will appear, and the program will continue to run echo 'Suffix'; //The text message will still be output ?>

Starting from PHP 5, we can use the new type constraint mechanism to type constraints on some data types of function parameters. Taking the above code as an example, we can require that the parameter passed in must be a Person object type when writing the sayHi() function, otherwise a fatal error will occur and the execution of the current page script will be terminated. It is very simple to use PHP's type constraint mechanism. We only need to add the specified type name before the parameter variable declared by the function. When we call this function, PHP will forcefully check whether the parameters of the function are of the specified type, and if not, a fatal error will be raised.

The code is as follows

Copy code

代码如下

复制代码

class Person {
public $name = 'CodePlayer';
public $age = 3;
}

function sayHi(Person $person){
echo "Hello! My name is $person->name. I'm $person->age years old.";
}

    $person = '张三';
    sayHi($person); //不是期望的Person对象类型，引发Fatal Error致命错误，程序终止运行
    echo 'Suffix'; //不会输出该文本信息，程序终止运行
    ?>

class Person {
public $name = 'CodePlayer';

public $age = 3;

}

function sayHi(Person $person){

echo "Hello! My name is $person->name. I'm $person->age years old."; }

代码如下

复制代码

//如下面的类
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';
}
?>

$person = 'Zhang San'; SayHi($person); //Not the expected Person object type, triggers a Fatal Error, and the program terminates echo 'Suffix'; //The text message will not be output and the program will terminate ?>

It is worth noting that in PHP 5, currently only parameter variables of object, interface, array, and callable types can use type constraints (array types are supported starting from PHP 5.1 version, and callable types are supported starting from PHP 5.4 version) supported). Note: If a parameter variable using type constraints does not declare its default value to be null, you cannot pass a null value to the corresponding parameter variable when calling the function, otherwise an error will also be reported. Type constraints cannot be used with scalar types such as int or string. Traits are not allowed either. Example #1 Type constraint example

The code is as follows

Copy code

//Such as the following class<🎜> class MyClass<🎜> {<🎜> /**<🎜> * Test function<🎜> * The first parameter must be an object of OtherClass class<🎜> */<🎜> Public function test(OtherClass $otherclass) {<🎜> echo $otherclass->var; } /** * Another test function * The first parameter must be an array */ Public function test_array(array $input_array) { print_r($input_array); } } /** * The first parameter must be a recursive type */ Public function test_interface(Traversable $iterator) { echo get_class($iterator); } /** * The first parameter must be a callback type */ Public function test_callable(callable $callback, $data) { call_user_func($callback, $data); } } // OtherClass class definition class OtherClass { Public $var = 'Hello World'; } ?>

When the parameters of the function call are inconsistent with the defined parameter types, a catchable fatal error will be thrown.

// Fatal error: The first parameter must be an object of OtherClass class
$myclass->test('hello');

The code is as follows

代码如下

复制代码

// 两个类的对象
$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);
?>

Copy code

代码如下

复制代码

// 如下面的类
class MyClass {
public $var = 'Hello World';
}

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

// 正确
$myclass = new MyClass;
MyFunction($myclass);
?>
类型约束允许 NULL 值：

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

}

test(NULL);
test(new stdClass);

// Objects of two classes
$myclass = new MyClass;
$otherclass = new OtherClass;

// Fatal error: The first parameter must be an instance of the OtherClass class
$foo = new stdClass;
$myclass->test($foo);

Type constraints are not only used in member functions of classes, but can also be used in functions:

The code is as follows

Copy code

// Such as the following class
class MyClass {
Public $var = 'Hello World';
}<🎜> <🎜>/**
* Test function
* The first parameter must be an object of the MyClass class
*/
function MyFunction (MyClass $foo) {
echo $foo->var;
} // Correct
$myclass = new MyClass;
MyFunction($myclass);
?>
Type constraints allow NULL values: <🎜>/* Accepts NULL values */
function test(stdClass $obj = NULL) {<🎜> <🎜>}<🎜> <🎜>test(NULL);
test(new stdClass);<🎜> <🎜>?> http://www.bkjia.com/PHPjc/632617.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/632617.htmlTechArticlephp is a weakly typed programming language. In a PHP program, the data type of a variable can automatically change as its value changes, and PHP will not force check the data type of the variable...

Related labels：

php php5 。 variable Can exist study data yes of program notes type constraint programming language along with

source：php.cn

Previous article：PHP study notes: Definition and traversal of arrays_PHP tutorial Next article：How can I make the installed version of apache and the existing iis use port 80 at the same time? _PHP Tutorial

Statement of this Website

The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn