标签分类 热门分类
当前位置:首页 > > ThinkPHP电子书网盘下载
ThinkPHP实战 ThinkPHP实战
码小辫

码小辫 提供上传

资源
43
粉丝
25
喜欢
463
评论
5

    ThinkPHP实战 PDF 原书超清版

    ThinkPHP电子书
    • 发布时间:

    给大家带来的一篇关于ThinkPHP相关的电子书资源,介绍了关于ThinkPHP、实战方面的内容,本书是由清华大学出版社出版,格式为PDF,资源大小28.5 MB,夏磊编写,目前豆瓣、亚马逊、当当、京东等电子书综合评分为:8.1

  • ThinkPHP实战 PDF 下载
  • 下载地址:https://pan.baidu.com/s/10YZcYEojiyWMJYtMJj5Xz
  • 分享码:vkj5
  • 读者评价

    之前系统的学习过php编程,零散的看过thinkphp的文档,买回来温故而知新,尽快上手很合适

    这本书,的确脉络清晰。对初学者来说,还可以的。但是有一些问题需要提出的。
    这本书用的框架是3.x的,不是现在官网的5.x版本的。所以呢,有满多东西在新版架构里面不适合了。
    不过呢,基本上,还是很清晰明了的讲了怎么使用ThinkPHP,其实,要求不高的话也够用了。
    我也是闲的没事儿干了翻翻…作为入门书籍还是可以的

    实用性强,都是实际项目中使用的实用技术,比如验证码,文件上传,图像处理,调试,安全,缓存等

    这本书和官网教程差不多,看的时候可以当成工具书吧

    感觉写的很一般,新手看不懂,高手很鸡肋,脉络不清晰!讲解没重点!总之感觉讲的很混乱!

    编辑推荐

    本书实战性很强,没有冗长的概念讲解,都是实际项目中使用的实用技术,比如验证码、文件上传、图像处理、调试、安全、缓存等。留言板、博客、论坛、微信公众平台开发4个实战项目案例,使读者尽快切入ThinkPHP企业级项目开发。 

    内容简介

    PHP是一种通用开源脚本语言,开源、跨平台、易于使用,主要适用于Web开发领域。MVC模式使得PHP在大型Web项目开发中耦合性低、重用性高、可维护性高、有利于软件工程化管理。本书以实用性为目标,系统地介绍了ThinkPHP框架的相关技术及其在Web开发中的应用。 全书共14章,每一章都是相对独立的知识点的集合。内容涵盖了ThinkPHP常用功能模块和实用技巧、MySQL数据库的设计与应用、完整的Web项目开发流程等目前PHP开发中*主流的技术,每一章都有大量的示例以及详尽的注释,便于读者的理解和掌握。*后通过4个完整的项目详细介绍了Web应用从设计到运行的各个环节,便于读者更好地实践。 对于拥有PHP基础而不知道下一步该做什么的读者而言,本书不失为一本好的入门教材,本书所有的实例都可以在Web开发中直接使用,使读者能够加快Web应用开发的进程。此外,本书也适合对于网络开发有兴趣的读者,以及大中专院校和培训机构的师生阅读与参考。

    内容节选

    TP的模块化设计

     

    名称 描述
    应用 基于同一个入口文件访问的项目我们称之为一个应用。
    模块 一个应用下面可以包含多个模块,每个模块在应用目录下面都是一个独立的子目录。
    控制器 每个模块可以包含多个控制器,一个控制器通常体现为一个控制器类。
    操作 每个控制器类可以包含多个操作方法,也可能是绑定的某个操作类,每个操作是URL访问的最小单元

    ThinkPHP的应用目录

    应用整体架构.JPG

    模块内部架构.JPG

    URL模式

     

    URL模式 URL_MODEL设置
    普通模式 0
    PATHINFO模式 1
    REWRITE模式 2
    兼容模式 3

    1.普通模式

    http://localhost/?m=home&c=user&a=login&var=value

    m参数表示模块,c参数表示控制器,a参数表示操作(当然这些参数都是可以配置的),后面的表示其他GET参数

    2.PATHINFO模式

    http://localhost/index.php/home/user/login/var/value/PATHINFO地址的前三个参数分别表示模块/控制器/操作。

    // 更改PATHINFO参数分隔符

    'URL_PATHINFO_DEPR'=>'-',

    前置和后置操作

    类似高级语言面向对象中的构造函数(前置)与析构函数(后置)

    系统会检测当前操作是否具有前置和后置操作,如果存在就会按照顺序执行,前置和后置操作的定义方式如下:

    class IndexController extends Controller{
    //前置操作方法
    public function _before_index(){
    echo 'before<br/>';
    }
    public function index(){
    echo 'index<br/>';
    }
    //后置操作方法
    public function _after_index(){
    echo 'after<br/>';
    }
    }

    需要注意的是,在有些方法里面使用了exit或者错误输出之类的话,有可能不会会再执行后置方法了。例如,如果在当前操作里面调用了控制器类的error方法,那么将不会再执行后置操作,但是不影响success方法的后置方法执行。

    作者简介

    夏磊,目前从事软件开发工作。精通PHP服务器脚本语言技术,善于把握运用新技术,如LAMP&LNMP平台以及Node.js平台下Web软件的开发、软件架构、设计模式等。作者博客上大量的PHP相关技术文章,深受读者好评。

    目录

    • 第1章  ThinkPHP入门 1
    • 1.1 MVC模式概述 1
    • 1.2 ThinkPHP是什么 2
    • 1.3  搭建PHP开发环境 2
    • 1.3.1 获取UPUPW 2
    • 1.3.2 安装UPUPW 3
    • 1.3.3 目录结构说明 4
    • 1.3.4 添加虚拟主机 4
    • 1.3.5 安装集成开发环境PHPStorm 6
    • 1.4  第一个ThinkPHP程序 7
    • 1.5  应用结构说明 8
    • 1.5.1 目录说明 8
    • 1.5.2 入口文件 8
    • 1.5.3 自动生成 9
    • 1.5.4 模块 9
    • 1.5.5 控制器 9
    • 1.6  术语解释 10
    • 1.7  小结 11
    • 第2章  配  置 12
    • 2.1  配置类型 13
    • 2.1.1 默认配置 13
    • 2.1.2 公共配置 13
    • 2.1.3 模式配置 13
    • 2.1.4 调试配置 14
    • 2.1.5 场景配置 14
    • 2.1.6 模块配置 14
    • 2.1.7 扩展配置 14
    • 2.1.8 动态配置 15
    • 2.2  配置操作 15
    • 2.2.1 C函数 16
    • 2.2.2 读取配置 17
    • 2.2.3 加载扩展配置 19
    • 2.2.4 写入配置 20
    • 2.3  小结 23
    • 第3章  路  由 24
    • 3.1 URL的三种模式 24
    • 3.1.1 动态URL 24
    • 3.1.2 静态URL 25
    • 3.1.3 伪静态URL 25
    • 3.2 ThinkPHP的路由 25
    • 3.2.1 路由模式 25
    • 3.2.2 路由配置 29
    • 3.3  小结 34
    • 第4章  控制器 35
    • 4.1  控制器的定义 35
    • 4.2  前置操作和后置操作 37
    • 4.3  动作参数绑定 38
    • 4.4  伪静态 40
    • 4.5 URL大小写 40
    • 4.6 URL生成 41
    • 4.6.1 地址表达式 41
    • 4.6.2 参数 41
    • 4.6.3 伪静态后缀 41
    • 4.6.4 URL模式处理 41
    • 4.6.5 生成路由地址 42
    • 4.7 Ajax返回 42
    • 4.8  重定向和页面跳转 43
    • 4.8.1 重定向 43
    • 4.8.2 页面跳转 44
    • 4.9 HTTP请求方法 46
    • 4.10 读取输入 48
    • 4.11 空操作 50
    • 4.12 空控制器 51
    • 4.13 小结 52
    • 第5章  模  型 53
    • 5.1  准备工作 53
    • 5.2  模型定义 54
    • 5.3  模型实例化 54
    • 5.3.1 new实例化 54
    • 5.3.2 M函数实例化 55
    • 5.3.3 D函数实例化 55
    • 5.3.4 空模型实例化 55
    • 5.4  连贯操作 55
    • 5.4.1 where 56
    • 5.4.2 table 57
    • 5.4.3 alias 57
    • 5.4.4 data 58
    • 5.4.5 field 58
    • 5.4.6 order 59
    • 5.4.7 limit 60
    • 5.4.8 page 61
    • 5.4.9 group 61
    • 5.4.10 having 61
    • 5.4.11 join 61
    • 5.4.12 union 62
    • 5.4.13 distinct 62
    • 5.4.14 lock 62
    • 5.4.15 cache 63
    • 5.4.16 fetchSql 63
    • 5.4.17 strict 64
    • 5.4.18 index 64
    • 5.5 CURD操作 64
    • 5.5.1 创建数据 64
    • 5.5.2 插入数据 65
    • 5.5.3 读取数据 65
    • 5.5.4 更新数据 66
    • 5.5.5 删除数据 67
    • 5.6  查询语言 68
    • 5.6.1 查询方式 68
    • 5.6.2 表达式查询 68
    • 5.6.3 快捷查询 70
    • 5.6.4 区间查询 71
    • 5.6.5 统计查询 71
    • 5.7  自动验证 72
    • 5.8  自动完成 78
    • 5.9  视图模型 82
    • 5.10 关联模型 85
    • 5.10.1 HAS_ONE 85
    • 5.10.2 BELONGS_TO 88
    • 5.10.3 HAS_MANY 89
    • 5.10.4 MANY_TO_MANY 90
    • 5.11 小结 91
    • 第6章  视  图 92
    • 6.1  模板定义 92
    • 6.2  模板主题 92
    • 6.3  模板赋值 93
    • 6.4  模板渲染 93
    • 6.5  总结 94
    • 第7章  模  板 95
    • 7.1  变量输出 95
    • 7.1.1 输出形式 95
    • 7.1.2 测试 96
    • 7.2  系统变量 98
    • 7.2.1 语法形式 98
    • 7.2.2 配置输出 98
    • 7.2.3 测试 98
    • 7.3  函数 100
    • 7.3.1 函数类型 100
    • 7.3.2 测试 100
    • 7.4  变量默认值 101
    • 7.4.1 语法形式 101
    • 7.4.2 测试 102
    • 7.5  算术运算符 103
    • 7.5.1 语法形式 103
    • 7.5.2 测试 103
    • 7.6  模板继承 105
    • 7.6.1 语法形式 105
    • 7.6.2 测试 106
    • 7.7  视图包含 107
    • 7.7.1 语法形式 107
    • 7.7.2 模板表达式 107
    • 7.7.3 模板文件 107
    • 7.7.4 测试 107
    • 7.8  内置标签 108
    • 7.8.1 volist标签 109
    • 7.8.2 foreach标签 110
    • 7.8.3 for标签 110
    • 7.8.4 switch标签 111
    • 7.8.5 比较标签 111
    • 7.8.6 empty标签 114
    • 7.8.7 defined标签 114
    • 7.8.8 标签嵌套 114
    • 7.8.9 import标签 115
    • 7.8.10 使用原生PHP 115
    • 7.8.11 不解析输出 115
    • 7.9  模板布局 116
    • 7.10 模板常量替换 116
    • 7.11 模板注释 117
    • 7.12 测试 118
    • 7.13 总结 126
    • 第8章  调  试 127
    • 8.1  调试模式 127
    • 8.2  异常处理 127
    • 8.3  日志 128
    • 8.3.1 日志级别 129
    • 8.3.2 记录方式 129
    • 8.3.3 写入日志 129
    • 8.4  变量输出 130
    • 8.5  执行统计 130
    • 8.6 SQL输出 131
    • 8.7  测试 131
    • 8.7.1 异常测试 131
    • 8.7.2 日志测试 132
    • 8.7.3 变量输出测试 133
    • 8.7.4 执行统计测试 133
    • 8.7.5 SQL输出测试 134
    • 8.8  总结 135
    • 第9章  缓  存 136
    • 9.1  数据缓存 136
    • 9.1.1 写入缓存 136
    • 9.1.2 读取缓存 136
    • 9.1.3 删除缓存 137
    • 9.2  页面缓存 137
    • 9.3  数据库查询缓存 138
    • 9.4  总结 139
    •  
    • 第10章  专  题 140
    • 10.1 session操作 140
    • 10.1.1 session写入 140
    • 10.1.2 session读取 140
    • 10.1.3 session删除 140
    • 10.2 cookie操作 141
    • 10.2.1 cookie写入 141
    • 10.2.2 cookie读取 141
    • 10.2.3 读取所有cookie 141
    • 10.2.4 cookie删除 141
    • 10.3 分页 141
    • 10.3.1 分页语法 141
    • 10.3.2 测试 142
    • 10.4 文件上传 145
    • 10.5 验证码 146
    • 10.6 图像处理 149
    • 10.6.1 实例化Image 149
    • 10.6.2 获取图片基本信息 149
    • 10.6.3 图像裁剪 150
    • 10.6.4 图像缩略图 151
    • 10.6.5 水印 152
    • 10.7 总结 153
    • 第11章  留言板项目实战 154
    • 11.1 项目目的 154
    • 11.2 项目需求 154
    • 11.3 数据表设计 154
    • 11.4 模块设计 155
    • 11.5 编码实现 155
    • 11.5.1 编写模型 155
    • 11.5.2 编写留言控制器 156
    • 11.5.3 编写用户控制器 159
    • 11.5.4 编写留言列表 162
    • 11.5.5 编写留言发表页面 163
    • 11.5.6 编写用户登录界面 163
    • 11.5.7 编写用户注册页面 164
    • 11.6 运行效果 165
    • 11.6.1 留言界面 165
    • 11.6.2 用户登录 166
    • 11.6.3 登录后留言列表 166
    • 11.6.4 发表留言 166
    • 11.6.5 留言成功 166
    • 11.6.6 注册页面 167
    • 11.7 项目总结 167
    • 第12章  博客系统项目实战 168
    • 12.1 项目目的 168
    • 12.2 需求分析 168
    • 12.3 功能设计 168
    • 12.4 数据库设计 169
    • 12.5 数据库字典 169
    • 12.6 模块设计 171
    • 12.6.1 Admin模块 171
    • 12.6.2 Common模块 175
    • 12.6.3 Home模块 177
    • 12.7 项目总结 182
    • 第13章  论坛系统项目实战 183
    • 13.1 项目目的 183
    • 13.2 功能设计 183
    • 13.3 数据库设计 183
    • 13.4 数据库字典 184
    • 13.5 模块设计 186
    • 13.5.1 Common模块 186
    • 13.5.2 Admin模块 190
    • 13.5.3 Home模块 192
    • 13.6 项目总结 193
    • 第14章  微信公众号开发 195
    • 14.1 项目目的 195
    • 14.2 功能设计 195
    • 14.3 开通测试公众号 196
    • 14.4 下载开发类库 197
    • 14.5 开始会话开发 197
    • 14.5.1 注册流程 199
    • 14.5.2 登录流程 200
    • 14.5.3 查看个人资料流程 200
    • 14.5.4 上传头像流程 200
    • 14.5.5 退出登录流程 200
    • 14.5.6 全局回复处理 201
    • 14.5.7 示例代码 201
    • 14.5.8 测试 212
    • 14.6 自定义菜单开发 213
    • 14.6.1 获取AccessToken 213
    • 14.6.2 创建自定义菜单 214
    • 14.6.3 响应自定义菜单 216
    • 14.7 项目总结 216
    • 结  语 217

     

    读书笔记

    PHP调整数组顺序使奇数位于偶数前(代码/闭包扩展)

    php如何实现原址排序数组使奇数位于偶数前面(代码)

    输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有的奇数位于数组的前半部分,所有的偶数位于数组的后半部分,并保证奇数和奇数,偶数和偶数之间的相对位置不变。

    1、遍历数组,判断元素奇数偶数,push进新数组,空间换时间

    2、插入排序的思想 空间上是原址排序

    2.1从前往后遍历,判断当前的是奇数

    2.2从当前的开始,从后往前遍历,如果是偶数就往后一位移动

    2.3当前奇数插入位置

    for i=1;i<arr.length;i++
        target=arr[i]
        if arr[i]%2==1
            j=i-1
            while j>=0&&arr[j]%2==0
                arr[j+1]=arr[j]
                j--
            arr[j+1]=target
    <?php
    $arr=array(1,2,3,4,5,6,7,8,9,10);
    function reOrderArray($arr){
            $length=count($arr);
            //从前往后遍历
            for($i=1;$i<$length;$i++){
                    //判断当前元素是奇数
                    $target=$arr[$i];
                    if($target%2==1){
                            //从后往前遍历,如果有偶数就往后移动一位
                            $j=$i-1;
                            while($j>=0 && $arr[$j]%2==0){
                                    $arr[$j+1]=$arr[$j];
                                    $j--;
                            }   
                            //把奇数插入位置
                            $arr[$j+1]=$target;
                    }   
            }   
            return $arr;
    }
     
    $arr2=reOrderArray($arr);
    var_dump($arr2);
    array(10) {
      [0]=>
      int(1)
      [1]=>
      int(3)
      [2]=>
      int(5)
      [3]=>
      int(7)
      [4]=>
      int(9)
      [5]=>
      int(2)
      [6]=>
      int(4)
      [7]=>
      int(6)
      [8]=>
      int(8)
      [9]=>
      int(10)
    }

    调整数组顺序使奇数位于偶数前(闭包扩展)

    这道题意思就是,给所有奇数放到偶数前面,我们可以设置两个指针,一个从前往后,直到他扫到偶数,一个从后往前,直到他扫到奇数,然后交换两个数的位置,然后往下扫,当begin>end的时候停止。代码实现很简单,如下:

    <?php
    //调整数组,使奇数位于偶数前面
    
    function reorder($arr){
            $length = count($arr);
            $begin = 0;
            $end = $length - 1;
            while($begin < $end){
                    //向后移动begin,直到它指到偶数
                    while(($begin < $end) && (($arr[$end] & 0x1) != 0)){
                            $begin++;
                    }
    
                    //向前移动end,指到它指到奇数
                    while(($begin < $end) && (($arr[$end] & 0x1) == 0)){
                            $end--;
                    }
    
                    if($begin < $end){
                            $temp = $arr[$begin];
                            $arr[$begin] = $arr[$end];
                            $arr[$end] = $temp;
                    }
            }
            return $arr;
    }
    
    $arr = [1,2,3,4,5,6,7,8];
    var_dump(reorder($arr));

    上面需要注意的时,判断一个数是奇数还是偶数的时候,我用的$num & 0x1 如果等于1,则为奇数,等于0,则为偶数,效率比%要高一些。

    到这里,如果单纯对于这道题,已经算是完事了。

    但是如果题目一改,将所有偶数放于奇数前,你可能又要重写一个函数了。

    这时,需求又改了,将所有能被3整除的放到前面………

    所有负数放到前面…….

    写完以上那么多函数,发现这些函数都类似啊,只有判断条件不一样。

    我们可不可以将整个函数,解耦成两部分,一个是判断数字应该在函数的前半部分还是后半部分,一个是交换数组位置。

    这时候我们就用到了闭包,代码如下

    <?php
    //调整数组,使奇数位于偶数前面
    
    function reorder($arr, $func){
            $length = count($arr);
            $begin = 0;
            $end = $length - 1;
            while($begin < $end){
                    //向后移动begin,直到它指到偶数
                    while(($begin < $end) && (!$func($arr[$begin]))){
                            $begin++;
                    }
    
                    //向前移动end,指到它指到奇数
                    while(($begin < $end) && ($func($arr[$end]))){
                            $end--;
                    }
    
                    if($begin < $end){
                            $temp = $arr[$begin];
                            $arr[$begin] = $arr[$end];
                            $arr[$end] = $temp;
                    }
            }
            return $arr;
    }
    
    $func = function($condition){
            $flag = ($condition & 0x1) == 0;
            return $flag;
    };
    
    $arr = [1,2,3,4,5,6,7,8];
    var_dump(reorder($arr, $func));

     

    《PHP、MySQL与JavaScript学习手册》学习笔记与总结

    php常用系统函数大全

    字符串函数

    strlen:获取字符串长度,字节长度

    substr_count 某字符串出现的次数

    substr:字符串截取,获取字符串(按照字节进行截取)

    mb_strlen
    mb_substr

    strchr:与substr相似,从指定位置截取一直到最后

    strrchr(获取文件后缀名):与strchr一样,只是从右边开始查找字符

    strtolower:所有的字符都小写(针对英文字母)

    strtoupper:所有的字符都大写

    strrev:字符串反转(只能反转英文:英文存储只有一个字节),按照字节进行反转

    strpos:从字符串中找对应字符出现的位置(数字下标),从最左边开始找

    strrpos:与strpos一样,只是从字符串的右边开始找

    trim:去掉函数两边的字符,默认是空格

    str_split 函数把字符串分割到数组中。

    chunk_split() 函数把字符串分割为一连串更小的部分

    str_repeat("Shanghai",5);把字符串 "Shanghai " 重复 5 次

    str_replace('\\', '/', dirname(DIR))); 替换

    ucfirst 首字母大写

    时间日期函数

    time:得到当前时间的时间戳(整型:从格林威治时间1970年1月1日0时0分0秒开始)秒数

    date:时间序列化函数,将指定的时间戳转换成规定时间日期的显示格式(随意的字符串:有专业的格式符规定),如果没有指定时间戳,系统默认使用当前时间的时间戳

    strtotime:时间日期格式的字符串转换成对应的时间戳(只要是正确的英语时间表达方式,都可以进行转换)

    microtime:微秒时间戳,根据不同的要求返回不同的结果 混合 microtime (布尔类型 ),可以返回一个浮点数的时间,也可以返回一个数组(时间戳和微秒数)

    数学相关函数

    abs:绝对值

    floor:向下取整 floor(3.2) 结果等于3

    ceil:向上取整

    round:四舍五入

    rand:取得一个指定范围内的随机整数

    mt_rand:取得一个指定范围内的随机整数(效率更高)

    min:PHP 会将非数值的 string 当成 0,但如果这个正是最小的数值则仍然会返回一个字符串。如果多个参数都求值为 0 且是最小值,min() 会返回按字母表顺序最小的字符串,如果其中没有字符串的话,则返回数值的 0;

    max:PHP 会将非数值的字符串当成 0,但如果这个正是最大的数值则仍然会返回一个字符串。如果多个参数都求值为 0 且是最大值,max() 会返回其中数值的 0,如果参数中没有数值的 0,则返回按字母表顺序最大的字符串。对于多个数组,max从左到右比较;如果同时出现数组和非数组参数总把数组作为最大值返回;

    数组相关函数

    count() // 非数组返回1

    key:获取当前数组当前指针所指向的元素的下标

    current:获取的当前指针指向元素的数值

    next:获取下一个元素的值,并且将指针下移

    prev:获取上一个元素的值,并且将指针上移

    end :将指针移到数组的最后一个元素,并返回最终指针位置的值

    reset:将指针移到数组的第一个元素,返回最终指针位置的值

    array_keys:获取一个数组的所有键名,返回一个索引数组

    array_values:获取一个数组的所有值,返回一个索引数组

    explode:爆炸,将一个字符串按照某个指定的规则(通常是特殊字符),将数组分成多个段,每一段都当做一个数组的元素,返回一个索引数组

    split 类似 explode explode('.', 'abc.txt')等于split('\.','abc.txt')

    implode:粘合,将一个数组内部的所有元素按照某个指定的规则(特殊字符),将所有的元素拼接成一个字符串

    join() 把数组元素组合为一个字符串

    array_merge:合并,指的是将两个数组中的元素进行累计。如果后面的数组与前面的数组有下标(键名:关联)相同的,那么后面的元素的值会覆盖前面的;如果是索引的相同下标,会自动的修改下标叠加到前面的数组里。

    array_reverse — 返回反转后的数组

    array_flip — 交换数组中的键和值

    数据结构模拟函数

    array_shift:从数组的前面弹出元素,得到元素的值

    array_pop:从数组的后面弹出元素,获得元素的值

    array_unshift:从数组的前面压入元素,得到当前数组元素的个数

    array_push:从数组的后面压入元素,得到当前数组元素的个数

    判断变量

    is_bool:判断是否是布尔类型

    is_float:判断浮点型

    is_integer:判断整型

    is_object:判断对象

    is_array:判断数组

    is_string:判断字符串

    is_resource:判断资源

    is_scalar:scalar是标量的,判断是基本数据类型:整型,浮点型,布尔型和字符串型

    is_null 检测变量是否为NULL 是返回TRUE 否则返回false。1.被赋值为NULL;2.变量没被赋值;3.被unset()

    is_numeric:判断数字或者纯数字组成的字符串

    gettype:获得数据类型

    settype:改变数据类型

    isset

    unset() 如果在函数中 unset() 一个全局变量,则只是局部变量被销毁,而在调用环境中的变量将保持调用 unset() 之前一样的值,如果在函数中 unset() 一个通过引用传递的变量,则只是局部变量被销毁,而在调用环境中的变量将保持调用 unset() 之前一样的值。

    empty//array(),"",0,"0",NULL,FALSE 都返回true

    文件操作函数

    opendir(路径):打开一个路径资源(将路径内部的所有数据读入到内存)

    readdir(路径资源):从文件夹资源中读取当前资源指针所指向的文件的名字,指针会向下移动一位

    closedir(资源):释放对应的文件资源

    scandir(路径):读取一个路径内部的所有文件名,返回一个数组,数组的每一个元素都是文件名。

    file_exists:判断一个文件是否存在(文件是广义:路径和文件)

    is_dir:判断一个指定路径是否存在(文件夹)

    is_file:判断一个指定路径是否是文件(文件)

    mkdir:创建一个路径,如果路径存在就会报错

    rmdir:移除文件夹

    file_get_contents:从一个指定的文件内读取数据内容。

    file_put_contents:将指定的字符串写入到对应的文件

    fopen:打开一个文件资源

    fgetc:c代表character,一次读取一个字符

    fgets:s代表string,代表可以读取多个字符,取决于指定的读取长度或者是否碰到换行(最多只能读取一行数据)

    两个函数都是对当前资源指针进行操作,读取之后都会将指针下移

    fread:获取指定长度的数据直到文件结束

    fwrite:向文件资源指针所在的位置写入数据,写东西不会将当前位置已有的东西往后移,而是会覆盖

    fseek:将指针指定到对应的位置

    fclose:使用对应的文件资源

    copy:复制

    unlink:删除文件

    rename:重命名文件

    filemtime:m代表modify,文件最后被修改的时间

    filesize:文件大小(字节)

    fileperms:文件权限(Linux下的八进制)

    排序

    rsort() 函数用于对数组单元从高到低进行排序。
    asort() 函数用于对数组单元从低到高进行排序并保持索引关系。
    arsort() 函数用于对数组单元从高到低进行排序并保持索引关系。
    ksort() 函数用于对数组单元按照键名从低到高进行排序。
    krsort() 函数用于对数组单元按照键名从高到低进行排序。

    报错

    error_reporting(E_ALL)

    ini_set('display_errors', 1)

    常量

    define() 定义常量
    defined() 检测常量是否定义

    序列化

    serialize

    unserialize

    json_encode 对变量进行 JSON 编码

    json_decode 对JSON 格式的字符串进行编码

    编码

    base64_encode 本函数将字符串以 MIME BASE64 编码。在 BASE64 编码后的字符串只包含英文字母大小写、阿拉伯数字、加号与反斜线,共 64 个基本字符,不包含其它特殊的字符,因而才取名 BASE64。

    base64_decode 解码

    MySQL常用命令

    # @Date    : 2017-11-15 13:18:34
    # @Author  : 师兵范 (shibingfan@163.com)
     
    #常用MySQL数据库命令
    +------------+----------------+
    | COMD       |   DESCRIPTION  | 
    +------------+----------------+
    |ALTER       |修改            |
    |BACKUP      |备份            | 
    |\C          |取消输入        | 
    |CREATE      |创建            | 
    |DELETE      |删除行          | 
    |DESCRIBE    |表结构          | 
    |DROP        |删除            | 
    |EXIT(CTRL-C)|退出            | 
    |GRANT       |修改权限        | 
    |HELP(\h,\?) |帮助            | 
    |INSERT      |插入            | 
    |LOCK        |锁住            | 
    |QUIT(\q)    |退出            | 
    |RENAME      |重命名          | 
    |SHOW        |项目说明        | 
    |SOURCE      |从文件名执行命令| 
    |STATUS(\s)  |显示当前状态    | 
    |TRUNCATE    |清空表          | 
    |UNLOCK      |解锁表          | 
    |UPDATE      |更新数据        | 
    |USE         |打开数据库      | 
    +------------+----------------+
    #显示已有数据库
    mysql> SHOW databaseS; 
    +--------------------+
    | Database           |
    +--------------------+
    | information_schema |
    | drupal7            |
    | mysql              |
    | northwind          |
    | performance_schema |
    | shibingfan         |
    | sys                |
    | testdb             |
    +--------------------+
    8 rows in set (0.06 sec)
    #创建数据库
    mysql> CREATE DATABASE publications;
    Query OK, 1 row affected (0.03 sec)
    #使用数据库
    mysql> USE publications;
    Database changed
    #数据库授权
    mysql> GRANT ALL ON publications.* TO 'shibingfan'@'localhost' IDENTIFIED BY 'shibingfan';
    Query OK, 0 rows affected, 1 warning (0.00 sec)
    #创建数据库表
    mysql> CREATE TABLE classics(
        -> author VARCHAR(128),
        -> title VARCHAR(128),
        -> type VARCHAR(16),
        -> YEAR char(4))ENGINE  MyISAM;
    Query OK, 0 rows affected (0.08 sec)
    #查询表结构
    mysql> DESCRIBE classics;
    +--------+--------------+------+-----+---------+-------+
    | Field  | Type         | Null | Key | Default | Extra |
    +--------+--------------+------+-----+---------+-------+
    | author | varchar(128) | YES  |     | NULL    |       |
    | title  | varchar(128) | YES  |     | NULL    |       |
    | type   | varchar(16)  | YES  |     | NULL    |       |
    | YEAR   | char(4)      | YES  |     | NULL    |       |
    +--------+--------------+------+-----+---------+-------+
    4 rows in set (0.02 sec)
    #数据类型
    CHAR(n)   VARCHAR(n)
    BINARY(n) VARBINARY(n)
    TEXT(n)   TINYTEXT(n)   MEDIUMTEXT(n)  LONGTEXT(n)
    TINYBLOB(n)  BLOB(n)
    TINYINT   SMALLINT      MEDIUMINT      INT/INTEGER    BIGINT
    FLOAT     DOUBLE/REAL
    DATETIME  DATE          TIMESTAMP      TIME           YEAR
    INT UNSIGNED,  NOT NULL,  AUTO_INCREMENT,  KEY
    #添加表列id
    mysql> ALTER TABLE classics ADD id INT UNSIGNED NOT NULL AUTO_INCREMENT KEY;
    Query OK, 0 rows affected (0.06 sec)
    Records: 0  Duplicates: 0  Warnings: 0
    #删除表列
    mysql> ALTER TABLE classics DROP id;
    Query OK, 0 rows affected (0.08 sec)
    Records: 0  Duplicates: 0  Warnings: 0
    #向表中添加数据
    mysql> INSERT INTO classics(author,title,type,year)VALUES('Shibingfan', 'LEARN MYSQL', 'EDUCATION', '1887');
    Query OK, 1 row affected (0.00 sec)
    #重命名表
    mysql> ALTER TABLE classics RENAME mytable ;
    Query OK, 0 rows affected (0.02 sec)
    #改变列数据类型
    mysql> ALTER TABLE mytable MODIFY year SMALLINT;
    Query OK, 5 rows affected (0.08 sec)
    #添加新列
    mysql> ALTER TABLE mytable ADD pages SMALLINT UNSIGNED;
    Query OK, 5 rows affected (0.08 sec)
    #重命名列
    mysql> ALTER TABLE mytable CHANGE type category VARCHAR(16);
    Query OK, 0 rows affected (0.31 sec)
    #删除列
    mysql> ALTER TABLE mytable DROP pages;//DROP命令不可逆
    Query OK, 5 rows affected (0.33 sec)
    #删除表
    mysql> DROP TABLE mytable;
    Query OK, 0 rows affected (0.02 sec)
    #创建索引
    mysql> ALTER TABLE mytable ADD INDEX(author(20));
    mysql> CREATE INDEX author ON mytable(author(20));//也可在创建表时添加索引
    Query OK, 5 rows affected (0.08 sec)
    #创建全文索引
    mysql> ALTER TABLE mytable ENGINE = MyISAM;		//将表转换为MyISAM
    mysql> ALTER TABLE mytable ADD FULLTEXT(author,title);
    #数据库查询
    SELECT * FROM mytable;
    SELECT author,title FROM mytable;
    SELECT COUNT(*) FROM mytable;			//计数
    SELECT DISTINCT author FROM mytable; 	//去重
    DELETE FROM mytable WHERE title = 'LEARN MYSQL';
    SELECT * FROM mytable WHERE author='Shibingfan';
    SELECT * FROM mytable WHERE author LIKE "Shi%";		//like关键字,模糊匹配
    SELECT author FROM mytable LIMIT 3;					//LIMIT关键字,限定返回的行数
    SELECT author FROM mytable LIMIT 3,1;				//LIMIT关键字,限定从表的什么位置开始返回多少行
    SELECT * FROM mytable WHERE MATCH(author,title) AGAINST('Shi'); //自然语言在FULLTEXT索引列上搜索
    SELECT * FROM mytable WHERE MATCH(author,title) AGAINST('+Shi -bing' IN BOLLEAN MODE);//布尔模式下搜索
    UPDATE mytable SET author='Shibf' WHERE author='shibingfan'; 	//更新数据
    SELECT author,title FROM mytable ORDER BY author;				//排序
    SELECT category,COUNT(author) FROM mytable GROUP BY category;	//分组
    #连接表,新建customers表
    SELECT * FROM mytable,customers WHERE mytable.isbn=customers.isbn;
    SELECT * FROM customers NATURAL JOIN mytable;		//自然连接,将相同列名的表自动合并
    SELECT * FROM customers JOIN mytable ON mytable.isbn=customers.isbn;
    SELECT author,title FROM mytable AS au,ti;			//AS重命名
    SELECT * FROM mytable,customers WHERE mytable.isbn=customers.isbn AND author='shibingfan';
     
     
    #事物
    #事物存储引擎InnoDB
    mysql> CREATE TABLE accounts(number INT, balance FLOAT, PRIMARY KEY(number))ENGINE InnoDB;
    mysql> INSERT INTO accounts(number,balance) VALUES(12345,1025.50);
    mysql> INSERT INTO accounts(number,balance) VALUES(67890,140.00);
    mysql> SELECT * FROM accounts ;
    +--------+---------+
    | number | balance |
    +--------+---------+
    |  12345 |  1025.5 |
    |  67890 |     140 |
    +--------+---------+
    #事物处理BEGIN, COMMIT, ROOLBACK
    mysql> BEGIN;
    mysql> UPDATE accounts SET balance=balance+25.11 WHERE number=12345;
    mysql> COMMIT; 		//确认提交,数据库发生更改
    mysql> ROLLBACK;	//回滚操作,数据库恢复到BEGIN之前的状态
    #使用EXPLAIN,得到查询快照,进而对查询进行优化
    mysql> EXPLAIN SELECT * FROM accounts WHERE number='12345';
    +----+-------------+----------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
    | id | select_type | table    | partitions | type  | possible_keys | key     | key_len | ref   | rows | filtered | Extra |
    +----+-------------+----------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
    |  1 | SIMPLE      | accounts | NULL       | const | PRIMARY       | PRIMARY | 4       | const |    1 |   100.00 | NULL  |
    +----+-------------+----------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
    #备份和恢复
    mysql> LOCK TABLES mytable READ,accounts READ;		//锁定表UNLOCK TABLES;
    mysql> mysqldump -u user -ppassword publications;
    mysql> mysqldump -u user -ppassword publications mytable > mytable.sql;
    mysql> mysqldump -u user -ppassword publications --all-database > all_db.sql;
    mysql> mysqldump -u user -ppassword < all_db.sql;
    mysql> mysqldump -u user -ppassword -D publications < mytable.sql;

     

    PHP7协程概念以及实现方法

    php7协程知识点

    多任务 (并行和并发)

    在讲协程之前,先谈谈多进程、多线程、并行和并发。

    对于单核处理器,多进程实现多任务的原理是让操作系统给一个任务每次分配一定的 CPU 时间片,然后中断、让下一个任务执行一定的时间片接着再中断并继续执行下一个,如此反复。

    由于切换执行任务的速度非常快,给外部用户的感受就是多个任务的执行是同时进行的。

    多进程的调度是由操作系统来实现的,进程自身不能控制自己何时被调度,也就是说: 进程的调度是由外层调度器抢占式实现的

    而协程要求当前正在运行的任务自动把控制权回传给调度器,这样就可以继续运行其他任务。这与抢占式的多任务正好相反, 抢占多任务的调度器可以强制中断正在运行的任务, 不管它自己有没有意愿。如果仅依靠程序自动交出控制的话,那么一些恶意程序将会很容易占用全部 CPU 时间而不与其他任务共享。

    协程的调度是由协程自身主动让出控制权到外层调度器实现的

    回到刚才生成器实现 xrange 函数的例子,整个执行过程的交替可以用下图来表示:

    协程可以理解为纯用户态的线程,通过协作而不是抢占来进行任务切换。

    相对于进程或者线程,协程所有的操作都可以在用户态而非操作系统内核态完成,创建和切换的消耗非常低。

    简单的说协程 就是提供一种方法来中断当前任务的执行,保存当前的局部变量,下次再过来又可以恢复当前局部变量继续执行。

    我们可以把大任务拆分成多个小任务轮流执行,如果有某个小任务在等待系统 IO,就跳过它,执行下一个小任务,这样往复调度,实现了 IO 操作和 CPU 计算的并行执行,总体上就提升了任务的执行效率,这也便是协程的意义

    多线程

    在单核下,多线程必定是并发的;

    不过现在的统一进程的多线程是可以运行在多核CPU下,所以可以是并行的

    并发(Concurrency)

    是指能处理多个同时性活动的能力,并发事件之间不一定要同一时刻发生。

    并行(Parallesim)

    是指同时发生的两个并发事件,具有并发的含义,而并发则不一定并行。
    多个操作可以在重叠的时间段内进行。

    并行和并发区别

    并发指的是程序的结构,并行指的是程序运行时的状态

    并行一定是并发的,并行是并发设计的一种

    单线程永远无法达到并行状态

    协程

    协程的支持是在生成器的基础上, 增加了可以回送数据给生成器的功能(调用者发送数据给被调用的生成器函数).

    这就把生成器到调用者的单向通信转变为两者之间的双向通信.

    我们在上篇文章已经讲过了send方法, 下面让我们理解下协程

    同步代码

    在没有涉及到异步执行代码之前,我们的代码都是这样的

    function printNum($max, $caller)
    {
      for ($i=0; $i<$max; $i++ ) {
        echo "调度者:" . $caller . " 打印:" . $i . PHP_EOL;
      }
    }
     
    printNum(3, "caller1");
    printNum(3, "caller2");
     
    # output
    调度者:caller1 打印:0
    调度者:caller1 打印:1
    调度者:caller1 打印:2
    调度者:caller2 打印:0
    调度者:caller2 打印:1
    调度者:caller2 打印:2

    使用协程后改进的代码

    初稿,手动调整生成器执行

    # 本代码手动调整了进程执行代码的顺序,当然本代码实现不用协程也可以,只是利用本流程说明协程作用
    # 生成器给了我们函数中断,协程[生成器send]给了我们重新唤起生成器函数的能力
    function printNumWithGen($max)
    {
      for ($i=0; $i<$max; $i++ ) {
        $res = yield $i;
        echo $res;
      }
    }
     
    $gen1 = printNumWithGen(3);
    $gen2 = printNumWithGen(3);
     
    // 手动执行caller1 再 caller2
    $gen1->send("调度者: caller1 打印:" . $gen1->current() . PHP_EOL);
    $gen2->send("调度者: caller2 打印:" . $gen2->current() . PHP_EOL);
     
    // 手动执行caller1 再 caller2
    $gen1->send("调度者: caller1 打印:" . $gen1->current() . PHP_EOL);
    $gen2->send("调度者: caller2 打印:" . $gen2->current() . PHP_EOL);
     
    // 手动执行caller2 再 caller1
    $gen2->send("调度者: caller2 打印:" . $gen2->current() . PHP_EOL);
    $gen1->send("调度者: caller1 打印:" . $gen1->current() . PHP_EOL);
     
    # output
    调度者: caller1 打印:0
    调度者: caller2 打印:0
    调度者: caller1 打印:1
    调度者: caller2 打印:1
    调度者: caller2 打印:2
    调度者: caller1 打印:2

    总结

    上面案例应该让大家理解了协程设计的意义和如何使用协程

    那么接下去我们为我们的协程自动一个自动调度器(Co自动执行器),无需再手动来中断和恢复了

    PHP7下协程的实现方法

    前言

    相信大家都听说过『协程』这个概念吧。

    但是有些同学对这个概念似懂非懂,不知道怎么实现,怎么用,用在哪,甚至有些人认为yield就是协程!

    我始终相信,如果你无法准确地表达出一个知识点的话,我可以认为你就是不懂。

    我写这篇文章的目的,是想对鸟哥文章做更加充足的补充,毕竟有部分同学的基础还是不够好,看得也是云头雾里的。

    什么是协程

    先搞清楚,什么是协程。

    你可能已经听过『进程』和『线程』这两个概念。

    进程就是二进制可执行文件在计算机内存里的一个运行实例,就好比你的.exe文件是个类,进程就是new出来的那个实例。

    进程是计算机系统进行资源分配和调度的基本单位(调度单位这里别纠结线程进程的),每个CPU下同一时刻只能处理一个进程。

    所谓的并行,只不过是看起来并行,CPU事实上在用很快的速度切换不同的进程。

    进程的切换需要进行系统调用,CPU要保存当前进程的各个信息,同时还会使CPUCache被废掉。

    所以进程切换不到费不得已就不做。

    那么怎么实现『进程切换不到费不得已就不做』呢?

    首先进程被切换的条件是:进程执行完毕、分配给进程的CPU时间片结束,系统发生中断需要处理,或者进程等待必要的资源(进程阻塞)等。你想下,前面几种情况自然没有什么话可说,但是如果是在阻塞等待,是不是就浪费了。

    其实阻塞的话我们的程序还有其他可执行的地方可以执行,不一定要傻傻的等!

    所以就有了线程。

    线程简单理解就是一个『微进程』,专门跑一个函数(逻辑流)。

    所以我们就可以在编写程序的过程中将可以同时运行的函数用线程来体现了。

    线程有两种类型,一种是由内核来管理和调度。

    我们说,只要涉及需要内核参与管理调度的,代价都是很大的。这种线程其实也就解决了当一个进程中,某个正在执行的线程遇到阻塞,我们可以调度另外一个可运行的线程来跑,但是还是在同一个进程里,所以没有了进程切换。

    还有另外一种线程,他的调度是由程序员自己写程序来管理的,对内核来说不可见。这种线程叫做『用户空间线程』。

    协程可以理解就是一种用户空间线程。

    协程,有几个特点:

    • 协同,因为是由程序员自己写的调度策略,其通过协作而不是抢占来进行切换
    • 在用户态完成创建,切换和销毁
    • ⚠️ 从编程角度上看,协程的思想本质上就是控制流的主动让出(yield)和恢复(resume)机制
    • 迭代器经常用来实现协程

    说到这里,你应该明白协程的基本概念了吧?

    PHP实现协程

    一步一步来,从解释概念说起!

    可迭代对象

    PHP5提供了一种定义对象的方法使其可以通过单元列表来遍历,例如用foreach语句。

    你如果要实现一个可迭代对象,你就要实现Iterator接口:

    <?php
    class MyIterator implements Iterator
    {
     private $var = array();
     public function __construct($array)
     {
      if (is_array($array)) {
       $this->var = $array;
      }
     }
     public function rewind() {
      echo "rewinding\n";
      reset($this->var);
     }
     public function current() {
      $var = current($this->var);
      echo "current: $var\n";
      return $var;
     }
     public function key() {
      $var = key($this->var);
      echo "key: $var\n";
      return $var;
     }
     public function next() {
      $var = next($this->var);
      echo "next: $var\n";
      return $var;
     }
     public function valid() {
      $var = $this->current() !== false;
      echo "valid: {$var}\n";
      return $var;
     }
    }
    $values = array(1,2,3);
    $it = new MyIterator($values);
    foreach ($it as $a => $b) {
     print "$a: $b\n";
    }

    生成器

    可以说之前为了拥有一个能够被foreach遍历的对象,你不得不去实现一堆的方法,yield关键字就是为了简化这个过程。

    生成器提供了一种更容易的方法来实现简单的对象迭代,相比较定义类实现Iterator接口的方式,性能开销和复杂性大大降低。

    <?php
    function xrange($start, $end, $step = 1) {
     for ($i = $start; $i <= $end; $i += $step) {
      yield $i;
     }
    }
    foreach (xrange(1, 1000000) as $num) {
     echo $num, "\n";
    }

    记住,一个函数中如果用了yield,他就是一个生成器,直接调用他是没有用的,不能等同于一个函数那样去执行!

    所以,yield就是yield,下次谁再说yield是协程,我肯定把你xxxx。

    PHP协程

    前面介绍协程的时候说了,协程需要程序员自己去编写调度机制,下面我们来看这个机制怎么写。

    0)生成器正确使用

    既然生成器不能像函数一样直接调用,那么怎么才能调用呢?

    方法如下:

    • foreach他
    • send($value)
    • current / next...

    1)Task实现

    Task就是一个任务的抽象,刚刚我们说了协程就是用户空间协程,线程可以理解就是跑一个函数。

    所以Task的构造函数中就是接收一个闭包函数,我们命名为coroutine。

    /**
     * Task任务类
     */
    class Task
    {
     protected $taskId;
     protected $coroutine;
     protected $beforeFirstYield = true;
     protected $sendValue;
    
     /**
      * Task constructor.
      * @param $taskId
      * @param Generator $coroutine
      */
     public function __construct($taskId, Generator $coroutine)
     {
      $this->taskId = $taskId;
      $this->coroutine = $coroutine;
     }
     /**
      * 获取当前的Task的ID
      * 
      * @return mixed
      */
     public function getTaskId()
     {
      return $this->taskId;
     }
     /**
      * 判断Task执行完毕了没有
      * 
      * @return bool
      */
     public function isFinished()
     {
      return !$this->coroutine->valid();
     }
     /**
      * 设置下次要传给协程的值,比如 $id = (yield $xxxx),这个值就给了$id了
      * 
      * @param $value
      */
     public function setSendValue($value)
     {
      $this->sendValue = $value;
     }
     /**
      * 运行任务
      * 
      * @return mixed
      */
     public function run()
     {
      // 这里要注意,生成器的开始会reset,所以第一个值要用current获取
      if ($this->beforeFirstYield) {
       $this->beforeFirstYield = false;
       return $this->coroutine->current();
      } else {
       // 我们说过了,用send去调用一个生成器
       $retval = $this->coroutine->send($this->sendValue);
       $this->sendValue = null;
       return $retval;
      }
     }
    }

    2)Scheduler实现

    接下来就是Scheduler这个重点核心部分,他扮演着调度员的角色。

    /**
     * Class Scheduler
     */
    Class Scheduler
    {
     /**
      * @var SplQueue
      */
     protected $taskQueue;
     /**
      * @var int
      */
     protected $tid = 0;
    
     /**
      * Scheduler constructor.
      */
     public function __construct()
     {
      /* 原理就是维护了一个队列,
       * 前面说过,从编程角度上看,协程的思想本质上就是控制流的主动让出(yield)和恢复(resume)机制
       * */
      $this->taskQueue = new SplQueue();
     }
     /**
      * 增加一个任务
      *
      * @param Generator $task
      * @return int
      */
     public function addTask(Generator $task)
     {
      $tid = $this->tid;
      $task = new Task($tid, $task);
      $this->taskQueue->enqueue($task);
      $this->tid++;
      return $tid;
     }
     /**
      * 把任务进入队列
      *
      * @param Task $task
      */
     public function schedule(Task $task)
     {
      $this->taskQueue->enqueue($task);
     }
     /**
      * 运行调度器
      */
     public function run()
     {
      while (!$this->taskQueue->isEmpty()) {
       // 任务出队
       $task = $this->taskQueue->dequeue();
       $res = $task->run(); // 运行任务直到 yield
    
       if (!$task->isFinished()) {
        $this->schedule($task); // 任务如果还没完全执行完毕,入队等下次执行
       }
      }
     }
    }

    这样我们基本就实现了一个协程调度器。

    你可以使用下面的代码来测试:

    <?php
    function task1() {
     for ($i = 1; $i <= 10; ++$i) {
      echo "This is task 1 iteration $i.\n";
      yield; // 主动让出CPU的执行权
     }
    }
    function task2() {
     for ($i = 1; $i <= 5; ++$i) {
      echo "This is task 2 iteration $i.\n";
      yield; // 主动让出CPU的执行权
     }
    }
    $scheduler = new Scheduler; // 实例化一个调度器
    $scheduler->newTask(task1()); // 添加不同的闭包函数作为任务
    $scheduler->newTask(task2());
    $scheduler->run();

    关键说下在哪里能用得到PHP协程。

    function task1() {
      /* 这里有一个远程任务,需要耗时10s,可能是一个远程机器抓取分析远程网址的任务,我们只要提交最后去远程机器拿结果就行了 */
      remote_task_commit();
      // 这时候请求发出后,我们不要在这里等,主动让出CPU的执行权给task2运行,他不依赖这个结果
      yield;
      yield (remote_task_receive());
      ...
    } 
    function task2() {
     for ($i = 1; $i <= 5; ++$i) {
      echo "This is task 2 iteration $i.\n";
      yield; // 主动让出CPU的执行权
     }
    }

    这样就提高了程序的执行效率。

    关于『系统调用』的实现,鸟哥已经讲得很明白,我这里不再说明。

    3)协程堆栈

    鸟哥文中还有一个协程堆栈的例子。

    我们上面说过了,如果在函数中使用了yield,就不能当做函数使用。

    所以你在一个协程函数中嵌套另外一个协程函数:

    <?php
    function echoTimes($msg, $max) {
     for ($i = 1; $i <= $max; ++$i) {
      echo "$msg iteration $i\n";
      yield;
     }
    }
    function task() {
     echoTimes('foo', 10); // print foo ten times
     echo "---\n";
     echoTimes('bar', 5); // print bar five times
     yield; // force it to be a coroutine
    }
    $scheduler = new Scheduler;
    $scheduler->newTask(task());
    $scheduler->run();

    这里的echoTimes是执行不了的!所以就需要协程堆栈。

    不过没关系,我们改一改我们刚刚的代码。

    把Task中的初始化方法改下,因为我们在运行一个Task的时候,我们要分析出他包含了哪些子协程,然后将子协程用一个堆栈保存。(C语言学的好的同学自然能理解这里,不理解的同学我建议去了解下进程的内存模型是怎么处理函数调用)

     /**
      * Task constructor.
      * @param $taskId
      * @param Generator $coroutine
      */
     public function __construct($taskId, Generator $coroutine)
     {
      $this->taskId = $taskId;
      // $this->coroutine = $coroutine;
      // 换成这个,实际Task->run的就是stackedCoroutine这个函数,不是$coroutine保存的闭包函数了
      $this->coroutine = stackedCoroutine($coroutine); 
     }

    当Task->run()的时候,一个循环来分析:

    /**
     * @param Generator $gen
     */
    function stackedCoroutine(Generator $gen)
    {
     $stack = new SplStack;
     // 不断遍历这个传进来的生成器
     for (; ;) {
      // $gen可以理解为指向当前运行的协程闭包函数(生成器)
      $value = $gen->current(); // 获取中断点,也就是yield出来的值
      if ($value instanceof Generator) {
       // 如果是也是一个生成器,这就是子协程了,把当前运行的协程入栈保存
       $stack->push($gen);
       $gen = $value; // 把子协程函数给gen,继续执行,注意接下来就是执行子协程的流程了
       continue;
      }
      // 我们对子协程返回的结果做了封装,下面讲
      $isReturnValue = $value instanceof CoroutineReturnValue; // 子协程返回`$value`需要主协程帮忙处理 
      if (!$gen->valid() || $isReturnValue) {
       if ($stack->isEmpty()) {
        return;
       }
       // 如果是gen已经执行完毕,或者遇到子协程需要返回值给主协程去处理
       $gen = $stack->pop(); //出栈,得到之前入栈保存的主协程
       $gen->send($isReturnValue ? $value->getValue() : NULL); // 调用主协程处理子协程的输出值
       continue;
      }
      $gen->send(yield $gen->key() => $value); // 继续执行子协程
     }
    }

    然后我们增加echoTime的结束标示:

    class CoroutineReturnValue {
     protected $value;
     
     public function __construct($value) {
      $this->value = $value;
     }
     // 获取能把子协程的输出值给主协程,作为主协程的send参数
     public function getValue() {
      return $this->value;
     }
    }
    function retval($value) {
     return new CoroutineReturnValue($value);
    }

    然后修改echoTimes:

    function echoTimes($msg, $max) {
     for ($i = 1; $i <= $max; ++$i) {
      echo "$msg iteration $i\n";
      yield;
     }
     yield retval(""); // 增加这个作为结束标示
    }

    Task变为:

    function task1()
    {
     yield echoTimes('bar', 5);
    }

    这样就实现了一个协程堆栈,现在你可以举一反三了。

    4)PHP7中yield from关键字

    PHP7中增加了yield from,所以我们不需要自己实现携程堆栈,真实太好了。

    把Task的构造函数改回去:

     public function __construct($taskId, Generator $coroutine)
     {
      $this->taskId = $taskId;
      $this->coroutine = $coroutine;
      // $this->coroutine = stackedCoroutine($coroutine); //不需要自己实现了,改回之前的
     }

    echoTimes函数:

    function echoTimes($msg, $max) {
     for ($i = 1; $i <= $max; ++$i) {
      echo "$msg iteration $i\n";
      yield;
     }
    }

    task1生成器:

    function task1()
    {
     yield from echoTimes('bar', 5);
    }

    这样,轻松调用子协程。

    总结

    这下应该明白怎么实现PHP协程了吧?

    实例分析PHP7的异常

    PHP 7 异常用于向下兼容及增强旧的assert()函数。它能在生产环境中实现零成本的断言,并且提供抛出自定义异常及错误的能力。

    老版本的API出于兼容目的将继续被维护,assert()现在是一个语言结构,它允许第一个参数是一个表达式,而不仅仅是一个待计算的 string或一个待测试的boolean。

    assert() 配置

    配置项默认值可选值
    zend.assertions1 1 - 生成和执行代码 (开发模式) 0 - 生成代码,但在执行时跳过它 -1 - 不生成代码 (生产环境)
    assert.exception0 1 - 断言失败时抛出,可以抛出异常对象,如果没有提供异常,则抛出 AssertionError 对象实例。 0 - 使用或生成 Throwable, 仅仅是基于对象生成的警告而不是抛出对象(与 PHP 5 兼容)

    参数

    assertion

    断言。在 PHP 5 中,是一个用于执行的字符串或者用于测试的布尔值。在 PHP 7 中,可以是一个返回任何值的表达式, 它将被执行结果用于指明断言是否成功。

    description

    如果 assertion 失败了,选项 description 将会包括在失败信息里。

    exception

    在 PHP 7 中,第二个参数可以是一个 Throwable 对象,而不是一个字符串,如果断言失败且启用了 assert.exception 该对象将被抛出。

    实例

    将 zend.assertions 设置为 0:

    <?php 
    ini_set('zend.assertions', 0); 
    
    assert(true == false); 
    echo 'Hi!'; 
    ?>

    以上程序执行输出结果为:

    Hi!

    将 zend.assertions 设置为 1,assert.exception 设置为 1:

    <?php 
    ini_set('zend.assertions', 1); 
    ini_set('assert.exception', 1); 
    
    assert(true == false); 
    echo 'Hi!'; 
    ?>

    以上程序执行输出结果为:

    Fatal error: Uncaught AssertionError: assert(true == false) in -:2
    Stack trace:
    #0 -(2): assert(false, 'assert(true == ...')
    #1 {main}
      thrown in - on line 2

     

    上一篇:深入PHP:面向对象、模式与实践  下一篇:PHP和MySQL Web开发

    展开 +

    收起 -

     
    ThinkPHP 相关电子书
    关于ThinkPHP的学习笔记

    Copyright 2018-2020 xz577.com 码农之家

    电子书资源由网友、会员提供上传,本站记录提供者的基本信息及资源来路

    鸣谢: “ 码小辫 ” 公众号提供回调API服务、“ 脚本CDN ”提供网站加速(本站寻求更多赞助支持)

    版权投诉 / 书籍推广 / 赞助:520161757@qq.com

    上传资源(网友、会员均可提供)

    查看最新会员资料及资源信息