Php5 type constraint learning Notes

Php is a weak programming language. in php programs, the data types of variables can automatically change with their values, php does not forcibly check or constrain the data type of the variable.

Php is a weak programming language. in php programs, the data types of variables can automatically change with their values, php does not forcibly check or constrain the data type of the variable.

We can refer to the following simple code example:

2. Class Person {
4. }
5. $ A = 1; // $ a is an Integer)
6. Var_dump ($ );
7. $ A = 1.0; // $ a is of the floating point type (Float)
8. Var_dump ($ );
9. $ A = 'codeplayer '; // at this time, $ a is of the String type (String)
10. Var_dump ($ );
11. $ A = array ('codeplayer '=> 'http: // www.111cn.net'); // at this time, $ a is an Array type (array)
12. Var_dump ($ );
13. $ A = new Person (); // at this time, $ a is of the Person Object type (Object)
14. Var_dump ($ );
15. $ A = mysql_connect ('localhost', 'username', 'password'); // $ a indicates the Resource type)
16. Var_dump ($ );
17. ?>

The weak data type of php makes it simple and flexible to use php. However, it is also a sword of damaklis, and it is precisely because of the characteristics of the weak data type of php, when writing php code, developers need to pay more attention to changes in variable data types, especially when passing variables as function parameters. after all, most function parameters only want to be a specific data type. for example, in the following example, the type of parameters that the function sayHi () expects to receive is the Person object type. However, because php is not a strongly typed language and does not forcibly check the type of the variable, we can pass any type of parameters to the function, resulting in program errors or logical exceptions, the instance code is as follows:

2. Class Person {
3. Public $ name = 'codeplayer ';
4. Public $ age = 3;
5. }
6. Function sayHi ($ person ){
7. Echo "Hello! My name is $ person-> name. I'm $ person-> age years old .";
8. }
9. $ P = 'Zhang San ';
10. SayHi ($ p); // if it is not the expected Person object type, a Notice-level error message will appear and the program continues to run.
11. Echo 'suffix '; // The text is still output.
12. ?>

From php 5, we can use the newly added type constraint mechanism to type some data types of function parameters. The code above is also used as an example. when writing the sayHi () function, the parameter must be of the Person object type. Otherwise, a Fatal Error is thrown ), and terminate the running of the script on the current page. To use the php type constraint mechanism, you only need to add the specified type name before the parameter variables declared by the function. When we call this function, php will forcibly check whether the function parameter is of the specified type. if it is not of the specified type, a fatal error is thrown. the code is as follows:

2. Class Person {
3. Public $ name = 'codeplayer ';
4. Public $ age = 3;
5. }
6. Function sayHi (Person $ person ){
7. Echo "Hello! My name is $ person-> name. I'm $ person-> age years old .";
8. }
9. $ Person = 'Zhang San ';
10. SayHi ($ person); // It is not the expected Person object type, causing a Fatal Error and program termination
11. Echo 'suffix '; // does not output the text information and the program stops running.
12. ?>

It is worth noting that in php 5, only parameter variables of the object, interface, array, and callable types can use type constraints (the array type is supported since php 5.1, callable type is supported from php 5.4 ).

Note: If the default value of a parameter variable with type constraints is not declared as null, you cannot pass a null value to the corresponding parameter variable when calling this function. Otherwise, an error is returned.

Type constraints cannot be used for scalar types such as int or string. Traits is not allowed.

Example #1 type constraints Example code:

2. // The following class
3. Class MyClass
4. {
5. /**
6. * Test functions
7. * The first parameter must be an object of the OtherClass class.
8. */
9. Public function test (OtherClass $ otherclass ){
10. Echo $ otherclass-> var;
11. }
12.  
13. /**
14. * Another test function
15. * The first parameter must be an array.
16. */
17. Public function test_array (array $ input_array ){
18. Print_r ($ input_array );
19. }
20. }
21. /**
22. * The first parameter must be of the recursive type.
23. */
24. Public function test_interface (Traversable $ iterator ){
25. Echo get_class ($ iterator );
26. }
28. /**
29. * The first parameter must be of the callback type.
30. */
31. Public function test_callable (callable $ callback, $ data ){
32. Call_user_func ($ callback, $ data );
33. }
34. }
35. // OtherClass class definition
36. Class OtherClass {
37. Public $ var = 'Hello World ';
38. }
39. ?>

When a function call parameter is different from the defined parameter type, a fatal error is thrown. the code is as follows:

2. // Two class objects
3. $ Myclass = new MyClass;
4. $ Otherclass = new OtherClass;
5. // Fatal error: The first parameter must be an object of the OtherClass class.
6. $ Myclass-> test ('Hello ');
7. // Fatal error: The first parameter must be an instance of the OtherClass class.
8. $ Foo = new stdClass;
9. $ Myclass-> test ($ foo );
10. // Fatal error: The first parameter cannot be null
11. $ Myclass-> test (null );
12. // Correct: output Hello World
13. $ Myclass-> test ($ otherclass );
14. // Fatal error: The first parameter must be an array
15. $ Myclass-> test_array ('a string ');
16. // Correct: output array
17. $ Myclass-> test_array (array ('A', 'B', 'C '));
18. // Correct: output ArrayObject
19. $ Myclass-> test_interface (new ArrayObject (array ()));
20. // Correct: output int (1)
21. $ Myclass-> test_callable ('Var _ dump', 1 );
22. ?>

The type constraint can also be used in functions, not only in member functions of the class. the code is as follows:

2. // The following class
3. Class MyClass {
4. Public $ var = 'Hello World ';
5. }
6. /**
7. * Test functions
8. * The first parameter must be an object of the MyClass class.
9. */
10. Function MyFunction (MyClass $ foo ){
11. Echo $ foo-> var;
12. }
13. // Correct
14. $ Myclass = new MyClass;
15. MyFunction ($ myclass );
16. ?>

Type constraints allow NULL values:

2. /* Accept NULL values */
3. Function test (stdClass $ obj = NULL ){
4. }
5. Test (NULL );
6. Test (new stdClass );
7. ?>