PHP learning function courseware_PHP tutorial

Code reuse
include()
require()
Both functions are used to reference files. The difference is that include() generates a warning when processing fails and require() is a dense error
include_once()
require_once()
These two functions are the same as include() and require(). The difference is that include_once and require_once can only be referenced once

Custom function
Custom functions use function() to declare the superiority of the
function:
Control the complexity of programming
Improve the reliability of the software
Improve the development efficiency of the software
Improve the reliability of the software Maintenance
Improve the reusability of the program
The syntax format of the custom function:
function function name (parameter 1, parameter 2) {
Content description of the program;
return;
}
Function name (parameter 1, parameter 2);
return return value; //The return value can also be an expression
Custom function names are not case-sensitive. When naming a function, you cannot use declared functions or PHP's built-in function names.
Judge whether a function exists: function_exists(function name);

Scope of variables
The visibility of a variable refers to the scope of the variable in the program.
Variables are generally divided into two types based on declaration: local variables and global variables
Local variables:
A variable declared in a function is a local variable, and the variable can only be added within the scope of the function use. If other programs need to call and use the variable value locally, they must use the "return" instruction to pass it back to the main program block for subsequent processing.
Global variables:
Variables declared outside the function scope are global variables. Since a function can be regarded as a separate program fragment, local variables will override the visibility of global variables, so global variables cannot be directly called and used in the function.
When you want to use a global variable in a function, you must use the global keyword to define the target variable to tell the function body that this variable is global.
You can also use the predefined global variable array $GLOBALS. This is a special variable that is automatically created when the program is running.
echo $GLOBALS["A"];
Variables can be manually deleted through unset($var). The variables will be released in memory and will no longer be in the global scope.
Using require and include will not affect the scope

Static variables
Declare function variables as static.
A static variable is shared between all calls to the function and is only initialized the first time the function is called during the execution of the script. To declare a function variable as static use the keyword static. Usually, a static variable is assigned an initial value the first time it is used.

Parameter passing
Passing parameters by value:
The parent program directly passes the specified value or variable to the function for use. Since the passed value or variable and the value in the function are stored in different memory blocks, when the function makes any changes to the imported value, it will not have a direct impact on the parent program.
Pass parameters by address (implemented with the "&" symbol)
Compared to the pass-by-value mode, the specified value or target variable in the parent program will not be passed to the function, but the value or variable's The relative address of the memory storage block is imported into the function. Therefore, when the value is changed in the function, it will also affect the parent program.

Default parameters
Default parameters must be listed after all parameters without default values.
function fun_sum($a,$b=0,$c=0){
return $a+$b+$c;
}
echo fun_sum(10,20);
echo fun_sum(10,20,30);
0 is the default parameter

Any number of parameter lists
func_get_args() //Returns an array containing all parameters
func_num_args() // Return the total number of parameters
func_get_arg() //Receive a numeric parameter and return the specified parameter. Find the value by subscript
function foo()
{
$numargs = func_num_args();
echo "Number of arguments: $numargs
n";
if ($numargs >= 2) {
echo "Second argument is: " . func_get_arg(1) . "< ;br />n";
}
$arg_list = func_get_args();
for ($i = 0; $i < $numargs; $i++) {
echo "Argument $i is : " . $arg_list[$i] . "
n";
}
}

foo(1, 2, 3);
Output result: Number of arguments: 3
Second argument is: 2
Argument 0 is: 1
Argument 1 is: 2
Argument 2 is: 3

Variable function
This means If there are parentheses after a variable name, PHP will look for a function with the same name as the variable's value and will try to execute it. Among other things, this can be used to implement callback functions, function tables, etc.

Recursive call
The so-called recursive function call means that the function can call and execute itself in its declared execution description.
Usually, a conditional judgment statement is attached to this type of function to determine whether a recursive call needs to be executed, and the recursive calling action of the function is terminated under specific conditions, and the control of the current process is returned to the previous layer. function execution. Therefore, when a function that performs recursive calls does not have additional conditional judgment statements, it may cause an infinite loop error.
The biggest advantage of recursive function calls is that it can simplify the complicated and repeated calling procedures in the program, and it can use this feature to to perform some more complex operations.
This courseware is phpchina teaching courseware
1210491967_9664e02c.rar

http://www.bkjia.com/PHPjc/319100.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/319100.htmlTechArticleCode reuse include() require() These two functions are used to reference files, the difference is when processing On failure include() produces a warning and require() is a dense error include_once()...