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:
$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.";
}
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.
The code is as follows
代码如下
复制代码
// 两个类的对象
$myclass = new MyClass;
$otherclass = new OtherClass;
// Objects of two classes
$myclass = new MyClass;
$otherclass = new OtherClass;
// Fatal error: The first parameter must be an object of OtherClass class
$myclass->test('hello');
// Fatal error: The first parameter must be an instance of the OtherClass class
$foo = new stdClass;
$myclass->test($foo);
// Fatal error: The first parameter cannot be null
$myclass->test(null);// Correct: Output Hello World
$myclass->test($otherclass);// Fatal error: The first parameter must be an array
$myclass->test_array('a string');//Correct: output array
$myclass->test_array(array('a', 'b', 'c'));//Correct: Output ArrayObject
$myclass->test_interface(new ArrayObject(array()));// Correct: output int(1)
$myclass->test_callable('var_dump', 1);
?>
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...
Statement：
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
