函数介绍

1.函数的概念
2.函数声明语法
3.函数调用方法
4.函数的传参方式
5.函数的作用域
6.动态函数
7.函数的参数个数与默认参数
8.函数的命名规范
9.函数的执行权与交回
10.超级全局变量
11.函数参数的引用赋值

从编程的角度来理解的。
把若干语句，封装在一块，起一个名字
下次根据名字来调用这个封装的块，就可以称之为函数

/*
假设如下场景：
来客人了，需要安排书童，沏茶
书童比较笨，需要你把步骤说的特别细
于是不客人来的时候
*/

echo '把水灌水壶，烧开','<br />';
echo '茶叶放到茶杯','<br />';
echo '把水倒进茶杯','<br />';
echo '端上茶杯','<br />';
//
////第二天，又来客人
////只好再对书童大喊4声

echo '把水灌水壶，烧开','<br />';
echo '茶叶放到茶杯','<br />';
echo '把水倒进茶杯','<br />';
echo '端上茶杯','<br />';
//第三天……又来客人了……
//第四天……又来客人了……

//我们思考，当客人来的时候，把'沏茶'这个过程执行一遍
//这样对书童说：客人来的时候，把'那个过程整体执行一遍？'

//书童的疑问：哪个过程？什么样的过程？
//
//教书童沏茶
//看好了，我把这4句话写在一块
{
echo '把水灌水壶，烧开','<br />';
echo '茶叶放到茶杯','<br />';
echo '把水倒进茶杯','<br />';
echo '端上茶杯','<br />';

}//包成一个复合语句， 一大句话。

//再给这个复合语句，加上一个名字就是函数名
function qicha(){
echo '把水灌水壶，烧开','<br />';
echo '茶叶放到茶杯','<br />';
echo '把水倒进茶杯','<br />';
echo '端上茶杯','<br />';
44 }//此时，函数已经有名字了。                 返回目录
qicha();

 从数字的角度来理解

函数的概念：函数是变量 之间的关系。

/*
例：y=2*x;

当：x=1,则y=2
……
……
可以看出，y与与x之间存储一种关系。
返回的y是根据x值乘以2


问男生：你谈过几个女朋友？
男生的真实谈过女朋友==他说的个数/3
女生的真实谈过的男朋友 ==她说的个数*3

来一个男友个数推测机
$real = $say *3;

给我一个数，我帮你算出一个3倍后的数---这样一个量与量的关系。
怎么给函数一个值，然后函数又怎么乘以3，再还给我呢？

给函数一个值
函数乘以3，再还给我

此时的函数，像不像豆浆机？
入口输入：黄豆
机器内：搅拌黄豆
出口：豆浆
*/

function she($say){ //参数的入口
    $real = $say *3;//函数体是加工处
    return $real; //出口
}

$num =5;
echo '大S说她谈过',$num,'次恋爱<br />';
echo '推测其真实谈过',she($num),'次恋爱<br />';

//函数的声明 的语法
//
//最简单的函数声明
function foo(){//没有参数
}

function foo($arg1,$arg2,$arg3){
return 值;//可以return 值，也可以不return 
}

//函数就是一个加工机
//输入黄豆，加工，return豆浆
//输入苹果，加工，return罐头
//输入淑女，加工，return 辣妹
//
function foo(){
    echo 'foo';
}

foo();

////如果函数指定的参数的话。
//// 还需要传参数
function bar($num){
echo $num*10;
}65 
bar(); //出错,缺少参数

函数的命名规范

//8.函数的命名规范

//和变量一样，不区大小写
//以后学到的面向对象时，方法（理解成函数）也是不区分大小写

function foo(){
    echo 'foo';
}
foo();                                                        返回目录

4.函数的传参方式

//4.函数的传参方式 
//
//长方形面积公式 = 长 * 高
//初中时：s = a * b
//
//高中时：s=α*β
//
//来分析 这3个公式，变的是什么，不变的是什么 ？
//
//用来表示矩形的2个边的‘名称’变了，叫‘长宽’，叫‘ab’……
//不变的是‘关系’，即无论表示方式怎么变，面积都始终等于长*宽
//
//你是中国人，你想让他帮你算面积的话
//你告诉他长，宽，没用
//
//要把你的长宽，让英国小孩脑子中，知道你在说的是a,b的值才行。

//
function 面积($长,$宽){
    return $长*$宽;
}
echo 面积(10,8);



//上面的过程，参数是如何传过去的？
//答：
//
//1.面积函数开始调用，在函数内部，声明两个变量,$长，$宽
//2.把接收到的值，按顺序分赋给形参
//3.此时，形参已经有值了
//4.函数体执行
//5.最后 返回
//
//-------------------------------------------------------
//
function she($say){ //参数的入口
    $real = $say *3;//函数体是加工处
    return $real; //出口

}
//
//she函数调用
//
//传参$num ，真正用的是什么？
//答：用的是$num的值
//函数先在函数体体内声明$say变量
//再把$num值，赋给$say 
//执行，返回
//
//模拟执行如下：
//
function she($say){ //参数的入口
    she($num);
    $say = $num;
    $real = $say *3;//函数体是加工处
    return $real; //出口

}
//--------------------------------------------------------
//声明函数时的参数 ---->叫形式上的参数，形参  --->变量名
//调用函数时的参数 ---->叫实际传递的参数，实参--->变量的值

//
function foo($num){
    $num += 1;
    $num *= 2;
    $num /= 3;
    $num += 999;
    return $num;
}

$price =100;
echo foo($price),'<br />';
echo $price;
//
////因为，在函数运行，$price的（值）传递给$num
//因此，函数体内的$num,无论怎么变，和$price无关了。
//=======================================================

//形参与实参的顺序/个数的关系，
//
//实参的值，要赋给形参变量

function foo($x,$y,$z){
return 2*$x+3*$y+$z;

}
echo foo(1,2,3);

//在调用的过程中，
//实参，形参，从左到右，严格的逐一对应
//一一对应上，然后实参值，挨个儿赋给形参
//
//
//如果实参少于形参，没对应上
echo foo(1,2);  //warning警告，并尽量往下执行。
//--------------------------------------------------------
//
echo foo(1,2,3,4,5);//还是11;
//因为实参对号给形参赋值时，后面多出来的实参，将会被舍弃掉

//---------------------------------------------------------       返回目录         

 参数的默认值

//参数的默认值
//来人报国籍
//要是指明自己是某国人，即说我自某国
//不指明，就默认为‘中国’

//
function intro($country='中国'){
    echo '我来自',$country,'<br />';
}

intro('美国');
intro('日本');
////--------------------------------------------------------
intro();

function intro($country='中国'){
    $country = '中国';
    echo '我来自',$country,'<br />';
}
//---------------------------------------------------------
intro('美国');
function intro($country='中国'){
    $country = '中国';
    $country = '美国';
    echo '我来自',$country,'<br />';
}

//----------------------------------------------------------

//默认参数，并不能改变，实参与形参，严格按顺序赋值的原则

function sum($x=4,$y,$z){
    return 2*$x + 3*$y + $z;
}
sum(5,6); //行吗？

//模拟执行：

sum(5,6); 

function sum($x=4,$y,$z){
    $x =4;
    $x = 5;
    $y =6;

    return 2*$x + 3*$y + $z;
}

//sum(4,5,6); //想一想，既然有了默认参数，调用时，又没能少传实参？
//想一想，怎么样才能少传一个实参，利用上默认上参数.

//如果参数有默认值的话，要把该参数写到后面去。

function sum($x,$y=3,$z=4){
return $x + 2*$y + $z;
}

echo sum(1);

//模拟执行：


function sum($x,$y=3,$z=4){
    $x = null;
    $y = 3;  
    $z = 4;//这三行是函数声明引起的

    $x = 1;// 这1行，是函数调用传实参引起的
    return $x + 2*$y + $z;
}

echo sum(1);  // 11
//----------------------------------------------------
//模拟执行：


function sun($x,$y=3,$z=4){
    $x = null;
    $y = 3;  
    $z = 4;//这三行是函数声明引起的

    $x = 1;// 这1行，是函数调用传实参引起的
    $y = 2;//这1行，是函数调用传实参引起的

    return $x + 2*$y + $z;
}
echo sun(1,2);  //  9

//
//函数可以设置默认值
//有默认值参数一般放在后面
//那么，实参的值，将要覆盖 默认值。                                  返回目录 

函数与变量的作用域 

//函数与变量的作用域

$num = 5;
function t(){
    $num = 9;
}
t();
echo $num;


//默认状况下 ，
//函数运行时，有其自己独有的变量空间
//函数体内的变量，与外界的变量，无关
//
//即使是变量的名字相同。


//当函数调用时，系统为其申请一块独立的‘调用空间’
//函数体内的变量，在其独立的‘调用空间内’
//与外界的变量无关。
//
//内部叫：局部变量
//外部叫：全局变量
//
//函数调用结束后，申请的独立的‘调用空间’，就释放掉
//下次，再调用，再申请，函数还得从头初始化

function t2(){  
    echo $num;
}
t2();

//-------------------------------------------------
var num = 5;
<script type="text/javascript">

    function t(){
        alert(num);
    }
</script>

t();

//在js中，有作用域链的概念，在函数内找不到局部变量num,就会往外层寻找。
//在php中，则不会跑到外层去寻找。

//-------------------------------------------------
//
function t2(){
    echo $num;

}

//t2(); //局部内，即t2的空间内，有$num变量吗?
//虽然全局内有$num,但php中，函数并不会去全局寻找$num
//简单说：php函数内的变量，就局限在函数的｛｝内。

function t3(){
    $age =19;
    $age+=1;
    echo $age,'<br />';
}

t3();
t3();
t3();

//-------------------------------------------------

function calc($num1,$act,$num2){
    $res =null;
   switch ($act){
        case '+':
            $res = $num1 + $num2;
            break;
        case '-':
           $res = $num1 - $num2;
            break;
        case '*':
            $res = $num1 * $num2;
            break;
        case '/':
            if($num2==0){
                echo '0不能作除数';
                break;
             }
            $res = $num1 / $num2;
            break;
   }
   return $res;
}


echo calc(3,'+',2),'<br />';
echo calc(3,'/',0),'<br />';

//====================================================

                                                                   返回目录 

超级全局变量  

//
//一般情况下，页面内声明的“普通全局变量”
// 在函数内访问不到，
//
//函数：常量 在函数能访问到
//而且，还有一类变量  ------超级全局变量任意一处，
//无论是多深层的函数内，还是以后的对象的方法体内，都可以直接访问到
//
//
//
//九大超级全局变量[注意全大写]
$_GET                 //地址栏的参数
$_POST                //接POST型的表单参数（比如：用户注册时的内容，往往用$_POST来接）
$_REQUEST             //默认情况下，包含了$_GET,$_POST,$_COOKIE的数组，即$_REQUEST是前三者的并集
                      //比如不想区分 $_GET,$POST  可以用$_REQUEST来代替

$_FILES               //文件上传时学

$_COOKIE              //用户登陆时学
$_SESSION

$_ENV
$_SERVER              //服务器还有访客一些信息,放置的是运行脚本的当前服务器信息，和当前运行的环境信息
$_GLOBLES             //所有变量的一个注册表



//----------------------------------------------------
function t2(){
    echo '你想注册<br />';
    echo '姓 名 是',$_POST['username'],'<br />';
    echo '密 码 是',$_POST['password'],'<br />';
    echo 'email 是',$_POST['email'],'<br />';
    echo '性 别 是',$_POST['sex'],'<br />';
}


function t(){
    $id =$_GET['id'];
    echo '如果我会mysql,将会取出',$id,'号贴子的内容给你';
    t2();
}

t();
//----------------------------------------------------
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="zh-CN">
<head>
<title>新建网页</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta name="description" content="" />
<meta name="keywords" content="" />
<script type="text/javascript">

</script>

<style type="text/css">
</style>
</head>
    <body>
        <form action="02.php?id=99" method="post">
          <h2>用户注册</h2>      
        <dd>用户名:<input type="text" name="username" /></dd>
        <dd>密  码:<input type="password" name="password" /></dd>
        <dd>E_mail:<input type="text" name="email" /></dd>
         
        <dd>性别:
                男<input type="radio" name="sex" value="男" />
                女<input type="radio" name="sex" value="女" /></dd>
        <dd><input type="submit" value="提交" /></dd>

        </form>
    </body>
</html>
//----------------------------------------------------

//id,email等都能打印出来
//这就说明，超全局变量，即使在函数内，甚至深层调用的函数内，也一样能接收


//有一天，经理告诉你，把来访者的IP记录下来。分析哪个省的客户最多
//并且，分析分析，用户用的是哪个浏览器





REMOTE_ADDR
remote_addr

echo '你来自',$_SERVER['REMOTE_ADDR'],'<br />';
echo '你的浏览器信息是',$_SERVER['HTTP_USER_AGENT'];
//为什么有的论坛，有一种动态签名档
//你去访问的时候显示
//
//你好，来自于北京电信的朋友，

//$GLOBALS是页面内所有全局变量的一个'名单',在GLOBALS里
//你能找到你声明过的所有变量


$a = 3;
$b ='hello';
print_r($GLOBALS);

//
//而$GLOBALS又是超全局的,这意味着:我们通过$GLOBALS可以操作普通的全局变量.
//
$var1 = 5;
$var2 = 1;
function get_value(){
    $var1 = 0;      //局部$var1
   $GLOBALS['var2']++;  //影响全局的var2,变成2
}

var_dump(get_value());
echo $var1,"\n";
echo $var2;

$age = 5;
function t(){
    global $age;  //global 关键字,用在变量前面,声明:这个变量是全局范围内的变量 ,而不要在局部内生成$age

    $age++;
}

t();

echo $age;


/*
函数 和局变量并不是水火不容的
1.通过引用传参,能影响全局变量 
2.通过global声明,也能直接使用外部的变量(不推荐,好多公司明确禁止使用global ,自己想想危害)
3.直接操作超级全局变量.
*/                                                                        返回目录 

动态函数 

//动态函数


*/

function wel(){
    echo '欢迎<br />';
}

function love(){
echo '基大都是<br />';
}
function cry(){
    echo '55<br />';
}
//执行哪一个呢？不一定
//决定，用户输入哪个函数名，我就执行哪个？


$func = $_GET['func'];//wel /love /cry 
echo $func;
echo $func();//加个小括号来调用，则会把$func的值，当成“函数名”，
//来调用该函数，php的灵活之处，以后学面向对象时，类名字也可以是变量

//同样的操作在java里，就要用反射
//即 函数名也可以用变量来表示
//====================================================


function t($num){
    $num+=5;
    return $num;
}

$age = 19;
echo t($age);
echo $age,'<br />'; //19

/*
function t($num){运行
$num = $age;
$num +=5;

}

                                                返回目录 

 函数的执行权与执行权的交回

函数的执行权与执行权的交回

function t(){
    echo 'a<br />';
    echo 'b<br />';
    echo 'c<br />';
}

echo 'x','<br />';
t();
echo 'z','<br />';//z是等到t函数运行结束后，才运行的

//总结：
//当调用函数的时候
//程序的执行权，进入到函数的内部





//运行x,z
//函数并没有发挥作用，因为没有调用
//
//
//函数就像一台加工机
//如豆浆机，如洗衣等
//
//豆浆机，洗衣机，人不去调用，会自动发挥作用吗？不会
//
//同理：函数写好后，并不会自动的发挥作用，得调用，才能发挥
//


//问：
//程序的执行权，进入到函数内部之后
//什么时候，交回执行权？

function t1(){
t2();
echo 't1<br />'

}

function t2(){
echo 't2<br />'
t3();
}

function t3(){
echo 't3<br />'
}   
 
t1();

 t2,t3,t1;


//1.函数的语句执行完毕后，执行权交回
//2.

function bar(){
    echo 'a';
    echo '<br />';
    return;

    echo 'b';
    echo 'c';
}
echo '<hr />';

echo 'x','<br />';
bar();
echo 'z';


//函数  既然比喻 成加工机
//入口----原料----传参数

/*
调用函数的返回值
即是return返回的值

如果没有return  语句，或者‘return;’
则返回值是NULL


思考：函数可不可以return 回来2个值？

答：不可能，函数的定义就决定了不能。
从数学上来，一组确定的参数，只能得到一个确定的函数结果
从程序来说，return 值;之后，函数结束，也不可能再return第2个值

有同学说：用数组
return array(1,2);// 数组是一个值，只不过是一个复合值。



function t3(){
return 3,9;
}

echo $x = t3();

//====================================================             返回目录 

 函数参数的引用赋值    

 函数参数的引用赋值
250 
251 */
252 //
253 function foo(&$num){   //此处，即是指传参，不再是传实参的值，而是传实参的地址
254     $num += 5;
255 
256 }
257 $age = 19;
258 echo foo($age),'<br />';
259 
260 $age = 19;
261 echo foo($age),'<br />';
262 function foo(&$num){   //此处，即是指传参，不再是传实参的值，而是传实参的地址
263     $num = &$age; //此时，函数内部的$num,指向外部的一个全局变量的地址
264     $num += 5;
265 
266 }
267 echo $age,'<br />';$age受到了foo函数的影响。                           返回目录 

 相关的视频连接：

1. 燕十八-PHP公益培训-YY直播-019-函数概念&声明&调用

2. 燕十八-PHP公益培训-YY直播-020-形参与实参概念详解

3. 燕十八-PHP公益培训-YY直播-021-实参传值过程详解

4. 燕十八-PHP公益培训-YY直播-022-函数的作用域

5 .燕十八-PHP公益培训-YY直播-023-函数的执行权与交回

6. 燕十八-PHP公益培训-YY直播-024-函数的返回值

7. 燕十八-PHP公益培训-YY直播-025-动态函数

8. 燕十八-PHP公益培训-YY直播-026-引用传参

9. 燕十八-PHP公益培训-YY直播-027-超全局变量