博客列表 >函数的声明与调用,函数返回值,函数参数,回调函数,函数命名空间

函数的声明与调用,函数返回值,函数参数,回调函数,函数命名空间

笼子猪
笼子猪原创
2020年07月09日 15:02:29864浏览

函数

1. 函数的声明与调用

  1. 函数是代码复用的重要手段

  2. ps:变量是数据复用的重要手段

  3. 函数分类(自定义函数,系统函数(内置函数),可变函数,匿名函数)

  1. /*
  2. 函数语法
  3. 声明一个函数
  4. function 函数名称的标识符:函数名(参数列表 arguments 形参){
  5. 函数体 (逻辑代码)
  6. }
  7. 函数调用
  8. 函数名(实参);
  9. */
  10. function sum(int $a, int $b):int
  11. {
  12. return $a + $b;
  13. }
  14. sum(1,6);
  • *自定义函数
  1. function comStr(string $a,string $b):string
  2. {
  3. return $a.$b;
  4. }
  5. comStr('盘','古');
  • *内置函数

PHP内部封装的函数(针对字符串,数组… 便于开发者使用)

内置函数有很多 记住常用的 其他的心里有个底就好 使用时再具体查看

  1. // 返回数组长度 PHP内置函数 count
  2. $arr1 = [
  3. {'name'=>'盘古','sex'=>'男'},
  4. {'name'=>'女娲','sex'=>'女'}
  5. ];
  6. echo count([1,23,4,5]); // 4
  7. echo count($arr1); // 2
  8. // 切割字符串 substr() mb_substr();
  9. // 使用 substr(需要切割的字符串,起始位置,切割长度);
  10. $userName = '世界那么大,我想去看看';
  11. echo substr($userName,0,6); // 世界
  12. echo mb_sbustr($userName,0,6); // 世界那么大,
  13. // 在utf-8编码中 中文占3个字符 在GBK编码中 中文占两个字符 substr() 是根据字符来切割的 所以所得结果不同
  • 可变函数

如果一个变量名后有小括号(),那么php就会寻找与变量值同名的函数并执行它。也就是说如果给一个变量赋不同的值,程序就会调用不同的函数

注意,可变函数不能直接用于例如 echo,print,unset,isset,empty,include,require 以及类似的语言结构 需要使用自己包装的函数来将这些结构用作可变函数

  1. function say(){
  2. echo '你好!世界';
  3. }
  4. function hobby(){
  5. echo '我爱打篮球';
  6. }
  7. function eat(){
  8. echo '今天吃了一大碗米饭!';
  9. }
  10. $funName = 'say';
  11. $funName();
  12. // 输出 你好!世界
  13. $funBame = 'hobby';
  14. $funName();
  15. // 输出 我爱打篮球
  16. $funName = 'eat';
  17. $funName();
  18. // 输出 今天我吃了...
  • 匿名函数 不具名(在php中也称为闭包)

js闭包: 在父函数中定义的函数 并且一定存在值的引用(js闭包可以访问3个作用域的变量 自己所在的作用域 父级作用域 以及全局作用域)

js 匿名函数不一定是闭包

js 父子级函数 不一定构成闭包 他们之间一定要存在值的引用(内部函数调用外部函数的变量)

PHP 将匿名函数做为闭包

可以访问父作用域中的变量

闭包的作用 扩展作用域 延长作用域链

  1. /*
  2. 闭包
  3. 函数内部通过 $GLOBALS 访问全局变量
  4. 也可以通过 global $con,.... 访问全局变量
  5. 可以通过 use(父级变量) 访问父级变量
  6. */
  7. $con = 0.6;
  8. $fun1 = function(float $price, int $num)use($con):float
  9. {
  10. return $price * $num * $con;
  11. };
  12. $fun1(1366,4);
  1. /*
  2. 闭包通过 use() 访问父级变量 并调用子函数
  3. */
  4. $con = 0.5;
  5. $f1 = function($price)
  6. {
  7. $f2 = function($num)use($price)
  8. {
  9. return $num * $price;
  10. };
  11. $f3 = function($num,$con)use($price)
  12. {
  13. return $num * $price * $con;
  14. };
  15. $arr = ['f2'=>$f2,'f3'=>$f3];
  16. return $arr;
  17. };
  18. echo $f1(1000)['f2'](3).'<br>';
  19. echo $f1(3600)['f3'](3,0.5);

闭包

函数总的分为 1.自定义函数(匿名函数,可变函数)和2.系统(内置)函数

2. 函数的返回值

  1. 函数必带返回值

  2. 函数返回值 通过 return 返回

  3. 函数 return 只能返回单值 如果需要返回多个返回值 可以使用 复合类型数据

  4. 重点放在多值返回

  1. // PHP关联数组和普通数组的区别
  2. // 1. 普通数组(索引数组)
  3. // 用数字做为键名的数组一般称为索引数组(索引数组的键是整数,一般从0开始)
  4. // 可以通过下标直接访问值
  5. $arr1 = [1,2,3,4,5];
  6. echo $arr1[0]; // 输出 1
  7. // 2. 关联数组
  8. // 关联数组与索引数组区别就是键值上,关联数组的键值是字符串,并且是开发者规定的 形成明确的索引键,形成键值对关系
  9. $arr2 = ['name'=>'cl','age'=>'52'];
  10. echo $arr2['name']; // 输出 cl
  1. 索引数组

索引数组

  1. 关联数组

关联数组

  1. // 定义一个函数 不写 return 此时 函数会默认返回 NULL
  2. function f(){
  3. echo '123';
  4. }
  5. // 打印结果 先输出 '123' 然后返回 NULL
  6. var_dump(f());
  7. // 函数默认返回 null(如果开发者不自定义返回值的话)

默认返回值

  1. PHP返回多值的方式
  1. // 1. 通过字符串拼接
  2. // 解决 返回 html与php混编不能返回多值的问题
  3. // 返回给前端后 前端不好操作
  4. function demo1():string
  5. {
  6. $status = 100;
  7. $message = '成功';
  8. return $status.$message;
  9. }
  10. demo1();
  1. // 2. 通过数组返回
  2. function demo2():array
  3. {
  4. $status = 100;
  5. $message = '查询成功';
  6. return ['status'=>$status,'message'=>$message];
  7. }
  8. // echo 不能打印数组
  9. // 只能通过 var_dump() print_r()
  10. demo2();
  1. // 3.通过json js对象字面量的字符串返回多值 通过 json_encode()加码
  2. function demo3():string
  3. {
  4. $status = 100;
  5. $message = '查询成功';
  6. $data = ['status'=>$status,'message'=>$message];
  7. return json_encode($data);
  8. }
  9. // 因为json_encode() 将其他类型的数据转换成字符串 所以此时可以使用 echo 打印 json_encode() 加码的数据
  10. echo demo3(); // 输出{"status":100,"message":"\u67e5\u8be2\u6210\u529f"}
  11. // 通过 json_decode()将 json字符串解码
  12. // 上一步加码的数据为数组 所以解码回来数据会变成json对象 所以不能使用echo
  13. // 不希望解码变成对象 可以在 json.decode()中加入第二个参数 true 返回json数组
  14. var_dump(json_decode(demo3())); // object(stdClass)#1 (2) { ["status"]=> int(100) ["message"]=> string(12) "查询成功" } object
  15. var_demp(json_decode(demo3,true)); // array(2) { ["status"]=> int(100) ["message"]=> string(12) "查询成功" } array
  16. // 前端通过 JSON.parse()可以将json字符串转换成 json数组
  17. // 前端通过 JSON.stringify(); 可以将 其他类型的值 转换成 json字符串
  18. // 前端常用 JSON.parse() 和 JSON.stringify()
  19. // 例如 做本地存储。。。
  20. var user = [];
  21. var data1 = {
  22. name:'cl',
  23. age:18,
  24. hobby:'篮球'
  25. };
  26. user.push(data1);
  27. // 通过 JSON.stringify() 将数组转成 json 字符串存储。
  28. localStorage.users = JSON.stringify(user);
  29. // 通过 JSON.parse(); 将json字符串转换成 json数组
  30. var data1 = JSON.parse(localStorage.users);
  31. console.log(data1);
  1. // 4.序列化方式 (系列化) 任何值 serialize();
  2. // 可以被多种语言调用
  3. serialize('123');
  4. $status = 100;
  5. $message = '查询成功';
  6. $data = ['status'=>$status,'message'=>$message];
  7. echo serialize($data);
  8. $data1 = serialize($data);
  9. // 反序列化 还原
  10. var_dump(unserialize($data1));

3.函数参数

  1. 值参数:默认 和变量的值传递类似 修改了其中一个变量不会修改另一个参数

  2. 引用参数:引用传参在形参前面加上 &(取地址符)当前实参的别名 并没有创建新的变量 和变量的引用传值一样。此时 参数变成引用传参 将内存地址传到函数内部 函数内部变化了内存地址所指向的变量 所以函数内部改变了变量 外部变量同时发生改变

  3. 默认参数: 参数的默认值 即没有传递参数时参数的默认的值 有默认参数的参数应该放在参数列表的最后面

  4. 剩余参数: …变量名 …$args 将所有参数整合到参数列表中 剩余参数用在参数列表中称为收集(归纳) 剩余参数用在函数的调用表达式中称为展开(扩展)

  1. // 1.值参数
  2. $price1 = 1200;
  3. function demo1($price){
  4. // return $price = $price * 2;
  5. return $price *= 2;
  6. }
  7. // 值参数不会改变参数本身
  8. echo demo1($price1); // 2400
  9. echo $price1 // 1200
  10. // 2. 引用参数
  11. // 引用参数需要用到 & (取地址符) 当前实参的别名 并没有创建新的变量 和变量的引用传值一样
  12. $price2 = 2000;
  13. fucntion demo2(&$price){
  14. // 函数内部对参数的更新会实时映射到外部实际参数
  15. return $price *= 2;
  16. }
  17. echo demo2($price2); // 4000
  18. echo $price2; // 4000
  19. // 3. 默认参数
  20. // 没有传参时默认的参数的值
  21. // 函数默认的参数应该放在没有默认参数的后面
  22. function moren($n,$price,$con=0.3){
  23. return $n * $price * $con;
  24. }
  25. // 没有传 $con参数 此时会使用$con的默认值 0.3
  26. echo demo3(4,2000);
  27. echo demo3(4,2000,0.5);
  28. // 4.剩余参数
  29. function demo3($a,$b,$c){
  30. return $a + $b + $c;
  31. }
  32. echo demo3(1,2,3);
  33. // 如果不知道参数的具体个数怎么操作呢?
  34. // 参数不固定
  35. // ...变量名 ...$args 将所有参数整合到数组中
  36. // 剩余参数 用在 函数的参数列表中 称为收集(归纳)
  37. // 将剩余参数用在函数的调用表达式中,是扩展
  38. // 收集
  39. function demo4(...$args){
  40. return array_num($args);
  41. }
  42. var_dump(demo5(1,2,3,4,5,6,7,8,9));
  43. echo demo5(1,2,3,4,5,6,7,8,9);
  44. // echo demo5(...$arr);
  45. // 扩展
  46. // 将剩余参数放到 调用 函数表达式中
  47. $arr = [1,23,4,5,6];
  48. echo demo5(...$arr);
  49. // 前面参数固定 后面参数不固定的情况
  50. function demo5($price,...$args){
  51. $data = ['price'=>$price,'other'=>array_sum($args)];
  52. return $data;
  53. }
  54. print_r(demo5(1000,1,23,4,5,6,7));
  55. // Array ( [price] => 1000 [other] => 46 )

参数

4.回调函数

  1. 回调函数,匿名函数,闭包(在PHP中这三个是一样的)

  2. 回调函数 常用于异步编程中的参数

  3. 异步编程:(对于函数的执行时间,无法预测 通过事件通过回调唤醒主程序)

  1. $data = range(1,100);
  2. // print_r($data);
  3. // 取出 偶数 (除数除2余0的为偶数)
  4. // array_map() 函数将用户自定义函数作用到数组中的每个值上,并返回用户自定义函数作用后的带有新值的数组
  5. // array_map(回调,作用数组);
  6. $arr = array_map(function($item){
  7. //echo $item;
  8. if($item % 2 === 0){
  9. return $item;
  10. }
  11. },$data);
  12. //print_r($arr);
  13. //过滤空值
  14. // array_filter()
  15. // array_filter(作用数组,回调函数)
  16. // 用回调函数过滤数组中的元素
  17. // 该函数把输入数组中的每个键值传给回调函数。如果回调函数返回 true,则把输入数组中的当前键值返回给结果数组。数组键名保持不变
  18. $arr1 = array_filter($arr,function($item){
  19. // 返回为true的值 空值 为false 所以直接 返回 $item
  20. // 返回条件为真的数据 空值为false 但 用在判断表达式中 空值也能返回true
  21. // return $item == '';
  22. return $item;
  23. });
  24. //print_r($arr1);
  25. // 数组重排 array_keys() array_values()
  26. $arr1 = array_values($arr1);
  27. print_r($arr1);
  28. // 当处理的数据为动态的 需要使用回调的方式处理结果(不会产生阻塞)

5. 函数命名空间

  1. 函数也属于全局成员 会存在同一个作用域不能重复定义的问题
  2. 解决办法 => 函数命名空间
  3. 命名空间解决全局成员命名冲突问题
  4. 公共函数库会使用到函数命名空间
  1. namespace ns1{
  2. function demo1(){
  3. return 'demo1';
  4. }
  5. // 同一个作用域 不能重复定义相同的全局变量
  6. // function demo1(){
  7. // return 'demo2';
  8. // }
  9. echo 'ns2';
  10. echo \ns2\demo1();
  11. }
  12. namespace ns2{
  13. function demo1(){
  14. return 'demo2';
  15. }
  16. echo \ns1\demo1();
  17. echo demo1();
  18. echo '<hr>';
  19. }
  20. namespace {
  21. // 全局命名空间
  22. echo \ns2\demo1();
  23. echo \ns1\demo1();
  24. echo '<hr>';
  25. echo ns1\demo1();
  26. echo ns2\demo1();
  27. }
  28. // 当前脚本使用了命名空间 则所有代码必须放在命名空间内
  29. // fucntion demo1(){
  30. // return 'demo1';
  31. // }

函数命名空间

声明:本文内容转载自脚本之家,由网友自发贡献,版权归原作者所有,如您发现涉嫌抄袭侵权,请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言,请遵守新闻评论服务协议