php面试宝典

Include和require的区别

区别一

Include引入文件的时候，如果碰到错误，会给出提示，并继续运行下边的代码。

Require引入文件的时候，如果碰到错误，会给出提示，并停止运行下边的代码。

区别二

用法上却有一些不同，include是有条件包含函数，而require则是无条件包含函数

Include 是比较松一点的‘包含’，如：文件不存在也不会出现什么问题，程序还可以往下执行。

Require是比较严格‘包含’，如：文件不存在或无权限访问时，程勋马上抛出错并终止。

PHP面向对象——三大基本特性与五大基本原则

三大特性是：封装、继承、多态

封装 把成员方法和成员属性封装到类中

多态是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果

五大基本原则

1.单一职责原则SRP(Single Responsibility Principle)

是指一个类的功能要单一，不能包罗万象。如同一个人一样，分配的工作不能太多，否则一天到晚虽然忙忙碌碌的，但效率却高不起来。

2.开放封闭原则OCP(Open－Close Principle)

一个模块在扩展性方面应该是开放的而在更改性方面应该是封闭的。比如：一个网络模块，原来只服务端功能，而现在要加入客户端功能，

那么应当在不用修改服务端功能代码的前提下，就能够增加客户端功能的实现代码，这要求在设计之初，就应当将服务端和客户端分开，公共部分抽象出来。

3.替换原则(the Liskov Substitution Principle LSP)

子类应当可以替换父类并出现在父类能够出现的任何地方。比如：公司搞年度晚会，所有员工可以参加抽奖，那么不管是老员工还是新员工，

也不管是总部员工还是外派员工，都应当可以参加抽奖，否则这公司就不和谐了。

 

4.依赖原则(the Dependency Inversion Principle DIP) 具体依赖抽象，上层依赖下层。

假设B是较A低的模块，但B需要使用到A的功能，这个时候，B不应当直接使用A中的具体类： 而应当由B定义一抽象接口，并由A来实现这个抽象接口，B只使用这个抽象接口：这样就达到了依赖倒置的目的，B也解除了对A的依赖，反过来是A依赖于B定义的抽象接口。通过上层模块难以避免依赖下层模块，假如B也直接依赖A的实现，那么就可能造成循环依赖。一个常见的问题就是编译A模块时需要直接包含到B模块的cpp文件，而编译B时同样要直接包含到A的cpp文件。

 

5.接口分离原则(the Interface Segregation Principle ISP)

模块间要通过抽象接口隔离开，而不是通过具体的类强耦合起来

 

php的垃圾回收机制

PHP可以自动进行内存管理，清除不需要的对象。
PHP使用了引用计数(reference counting) GC机制。
每个对象都内含一个引用计数器refcount，每个reference连接到对象，计数器加1。当reference离开生存空间或被设为NULL，计数器减1。当某个对象的引用计数器为零时，PHP知道你将不再需要使用这个对象，释放其所占的内存空间。

 

Session和cookie的区别

1. cookie是一文本文件格式存储在浏览器中，而session存储在服务端。它存储限制数据量。它只允许4kb。它没有在cookie中保存多个变量。
2. cookie的存储限制了数据量，只允许4kb,而session是无限量的
3. 我们可以轻松访问cookie值但是我们无法轻松访问session值，因此session更安全
4. 设置cookie时间可以使cookie过期。但是使用session-destory，我们将会销毁会话。

 

为什么禁用cookie就不能得到session呢

因为session是用sessionID来确定当前对话所对应的服务器session，而session ID是用过cookie来传递的，禁用cookie相当于失去了sessionID，也就得不到session了。

 

如何修改SESSION的生存时间
1. 设置浏览器保存的sessionid失效时间 setcookie(session_name(), session_id(), time() + $lifeTime, "/");
2. 可以使用SESSION 自带的 session_set_cookie_params(86400); 来设置 Session 的生存期
3. 通过修改php.ini中的session.gc_maxlifetime参数的值就可以改变session的生存时间

 

PDO、adoDB、PHPLib数据库抽象层比较
PHP数据库抽象层就是指，封装了数据库底层操作的介于PHP逻辑程序代码和数据库之间的中间件。
PDO以PHP 5.1为基础进行设计，它使用C语言做底层开发，设计沿承PHP的特点，以简洁易用为准，从严格意义上讲，PDO应该归为PHP 5的SPL库之一，而不应该归于数据抽象层，因为其本身和MySQL和MySQLi扩展库的功能类似。PDO是不适合用在打算或者有可能会变更数据库的系 统中的。

ADODB不管后端数据库如何，存取数据库的方式都是一致的；

转移数据库平台时，程序代码也不必做太大的更动，事实上只需要改动数据库配置文 件。提供了大量的拼装方法，目的就是针对不同的数据库在抽象层的底层对这些语句进行针对性的翻译，以适应不同的数据库方言！但是这个抽象层似乎体积过于庞 大了，全部文件大概有500K左右，如果你做一个很小的网站的话，用这个似乎大材小用了

PHPLib可能是伴随PHP一同成长最老的数据库抽象层（但和ADODB相比，它只算是一个MySQL抽象类库），这个抽象类使用方法相当简单，体积小，是小型网站开发不错的选择。

PDO提供预处理语句查询、错误异常处理、灵活取得查询结果（返回数组、字符串、对象、回调函数）、字符过滤防止SQL攻击、事务处理、存储过程。

ADODB支持 缓存查询、移动记录集、（HTML、分页、选择菜单生成）、事务处理、输出到文件。

 

设计模式

创建型：单例模式、工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式

结构型：适配器、桥接、过滤器、组合、装饰、外观、享元、代理

行为型：责任链、命令、解释器、迭代器、中介者、备忘录、观察者、状态、空对象

J2EE型：mvc、业务代表、组合实体、数据访问对象、前端控制器、拦截过滤器、服务定位器、传输对象

单例模式 三私一公 私有构造方法、私有属性、私有函数、公共函数常用于连接mysql数据库 防止外部实例化盗链 只能实例化一次

工厂模式 高内聚低耦合  工厂类调用自身静态方法来生成对象实例

 

Php四种基础算法

分别用 冒泡排序法，快速排序法，选择排序法，插入排序法将下面数组中 的值按照从小到的顺序进行排序。

$arr(1,43,54,62,21,66,32,78,36,76,39);

 

1. 冒泡排序法

 *     思路分析：法如其名，就是像冒泡一样，每次从数组当中 冒一个最大的数出来。

 *     比如：2,4,1    // 第一次 冒出的泡是4

 *                2,1,4   // 第二次 冒出的泡是 2

 *                1,2,4   // 最后就变成这样

$arr=array(1,43,54,62,21,66,32,78,36,76,39);  

function getpao($arr)

{  

  $len=count($arr);

  //设置一个空数组 用来接收冒出来的泡

  //该层循环控制 需要冒泡的轮数

  for($i=1;$i<$len;$i++)

  { //该层循环用来控制每轮 冒出一个数 需要比较的次数

    for($k=0;$k<$len-$i;$k++)

    {

       if($arr[$k]>$arr[$k+1])

        {

            $tmp=$arr[$k+1];

            $arr[$k+1]=$arr[$k];

            $arr[$k]=$tmp;

        }

    }

  }

  return $arr;

}

 

2. 选择排序法：

 

选择排序法思路： 每次选择一个相应的元素，然后将其放到指定的位置

function select_sort($arr) {

//实现思路 双重循环完成，外层控制轮数，当前的最小值。内层 控制的比较次数

    //$i 当前最小值的位置， 需要参与比较的元素

    for($i=0, $len=count($arr); $i<$len-1; $i++) {

        //先假设最小的值的位置

        $p = $i;

        //$j 当前都需要和哪些元素比较，$i 后边的。

        for($j=$i+1; $j<$len; $j++) {

            //$arr[$p] 是 当前已知的最小值

            if($arr[$p] > $arr[$j]) {

     //比较，发现更小的,记录下最小值的位置；并且在下次比较时，

 // 应该采用已知的最小值进行比较。

                $p = $j;

            }

        }

        //已经确定了当前的最小值的位置，保存到$p中。

 //如果发现 最小值的位置与当前假设的位置$i不同，则位置互换即可

        if($p != $i) {

            $tmp = $arr[$p];

            $arr[$p] = $arr[$i];

            $arr[$i] = $tmp;

        }

    }

    //返回最终结果

    return $arr;

}

 

3.插入排序法

插入排序法思路：将要排序的元素插入到已经 假定排序号的数组的指定位置。

function insert_sort($arr) {

    //区分 哪部分是已经排序好的

    //哪部分是没有排序的

    //找到其中一个需要排序的元素

    //这个元素 就是从第二个元素开始，到最后一个元素都是这个需要排序的元素

    //利用循环就可以标志出来

    //i循环控制 每次需要插入的元素，一旦需要插入的元素控制好了，

    //间接已经将数组分成了2部分，下标小于当前的（左边的），是排序好的序列

    for($i=1, $len=count($arr); $i<$len; $i++) {

        //获得当前需要比较的元素值。

        $tmp = $arr[$i];

        //内层循环控制 比较 并 插入

        for($j=$i-1;$j>=0;$j--) {

   //$arr[$i];//需要插入的元素; $arr[$j];//需要比较的元素

            if($tmp < $arr[$j]) {

                //发现插入的元素要小，交换位置

                //将后边的元素与前面的元素互换

                $arr[$j+1] = $arr[$j];

                //将前面的数设置为 当前需要交换的数

                $arr[$j] = $tmp;

            } else {

                //如果碰到不需要移动的元素

           //由于是已经排序好是数组，则前面的就不需要再次比较了。

                break;

            }

        }

    }

    //将这个元素 插入到已经排序好的序列内。

    //返回

    return $arr;

}

 

4.快速排序法  

function quick_sort($arr) {

    //先判断是否需要继续进行

    $length = count($arr);

    if($length <= 1) {

        return $arr;

    }

    //如果没有返回，说明数组内的元素个数 多余1个，需要排序

    //选择一个标尺

    //选择第一个元素

    $base_num = $arr[0];

    //遍历 除了标尺外的所有元素，按照大小关系放入两个数组内

    //初始化两个数组

    $left_array = array();//小于标尺的

    $right_array = array();//大于标尺的

    for($i=1; $i<$length; $i++) {

        if($base_num > $arr[$i]) {

            //放入左边数组

            $left_array[] = $arr[$i];

        } else {

            //放入右边

            $right_array[] = $arr[$i];

        }

    }

    //再分别对 左边 和 右边的数组进行相同的排序处理方式

    //递归调用这个函数,并记录结果

    $left_array = quick_sort($left_array);

    $right_array = quick_sort($right_array);

    //合并左边 标尺 右边

    return array_merge($left_array, array($base_num), $right_array);

}

 

thinkPHP框架与ci框架的区别

1. thinkPHP是国内人创造的，ci框架是国外人所创造的
2. thinkPHP是重量级框架使用与大型项目，ci属于轻量级框架适用于小型项目

Apache和NGINX的区别

Nginx

1．轻量级，采用 C 进行编写，同样的 web 服务，会占用更少的内存及资源

抗并发，nginx 以 epoll and kqueue 作为开发模型，处理请求是异步非阻塞的，负载能力比 2．apache 高很多，而 apache 则是阻塞型的。在高并发下 nginx 能保持低资源低消耗高性能 ，而 apache 在 PHP 处理慢或者前端压力很大的情况下，很容易出现进程数飙升，从而拒绝服务的现象。

3.nginx 处理静态文件好，静态处理性能比 apache 高三倍以上

4.nginx 的设计高度模块化，编写模块相对简单

5.nginx 配置简洁，正则配置让很多事情变得简单，而且改完配置能使用 -t 测试配置有没有问题，apache 配置复杂 ，重启的时候发现配置出错了，会很崩溃

6.nginx 作为负载均衡服务器，支持 7 层负载均衡

7.nginx 本身就是一个反向代理服务器，而且可以作为非常优秀的邮件代理服务器

8.启动特别容易, 并且几乎可以做到 7*24 不间断运行，即使运行数个月也不需要重新启动，还能够不间断服务的情况下进行软件版本的升级

9.社区活跃，各种高性能模块出品迅速

Apache

1.apache 的 rewrite 比 nginx 强大，在 rewrite 频繁的情况下，用 apache

2.apache 发展到现在，模块超多，基本想到的都可以找到

3.apache 更为成熟，少 bug ，nginx 的 bug 相对较多

4.apache 超稳定

5.apache 对 PHP 支持比较简单，nginx 需要配合其他后端用

6.apache 在处理动态请求有优势，nginx 在这方面是鸡肋，一般动态请求要 apache 去做，nginx 适合静态和反向。

7.apache 仍然是目前的主流，拥有丰富的特性，成熟的技术和开发社区

 

 

长连接、短连接的区别和使用

长连接：client方与server方先建立连接，连接建立后不断开，然后再进行报文发送和接收。这种方式下由于通讯连接一直存在。此种方式常用于P2P通信。
短连接：Client方与server每进行一次报文收发交易时才进行通讯连接，交易完毕后立即断开连接。此方式常用于一点对多点通讯。C/S通信。
长连接与短连接的使用时机：
长连接：
短连接多用于操作频繁，点对点的通讯，而且连接数不能太多的情况。每个TCP连 接的建立都需要三次握手，每个TCP连接的断开要四次握手。如果每次操作都要建立连接然后再操作的话处理速度会降低，所以每次操作下次操作时直接发送数据 就可以了，不用再建立TCP连接。例如：数据库的连接用长连接，如果用短连接频繁的通信会造成socket错误，频繁的socket创建也是对资源的浪 费。
短连接：
web网站的http服务一般都用短连接。因为长连接对于服务器来说要耗费一定 的资源。像web网站这么频繁的成千上万甚至上亿客户端的连接用短连接更省一些资源。试想如果都用长连接，而且同时用成千上万的用户，每个用户都占有一个 连接的话，可想而知服务器的压力有多大。所以并发量大，但是每个用户又不需频繁操作的情况下需要短连接。

 

HTTP协议详解、应用

http（超文本传输协议）是一个基于请求与响应模式的、无状态的、短连接、灵活、应用层的协议，常基于TCP 的连接方式。

参考 http://blog.csdn.net/gueter/article/details/1524447  (http协议详解)

(HTTP响应状态码)

HTTP响应状态码

状态代码有三位数字组成，第一个数字定义了响应的类别，且有五种可能取值：

1xx：指示信息--表示请求已接收，继续处理

2xx：成功--表示请求已被成功接收、理解、接受

3xx：重定向--要完成请求必须进行更进一步的操作

4xx：客户端错误--请求有语法错误或请求无法实现

5xx：服务器端错误--服务器未能实现合法的请求

常见状态代码、状态描述、说明：

200 OK      //客户端请求成功

400 Bad Request  //客户端请求有语法错误，不能被服务器所理解

401 Unauthorized //请求未经授权，这个状态代码必须和WWW-Authenticate报头域一起使用  403 Forbidden  //服务器收到请求，但是拒绝提供服务

404 Not Found  //请求资源不存在，eg：输入了错误的URL

500 Internal Server Error //服务器发生不可预期的错误

503 Server Unavailable  //服务器超时          //可能恢复正常

304 Not Modifed  //自从上次请求后，请求的网页未修改过。

//服务器返回此响应时，不会返回网页内容。

Mysql数据库主要包括以下五大类：

整数类型：BIT、BOOL、TINY INT、SMALL INT、MEDIUM INT、 INT、 BIG INT

浮点数类型：FLOAT、DOUBLE、DECIMAL

字符串类型：CHAR、VARCHAR、TINY TEXT、TEXT、MEDIUM TEXT、LONGTEXT、TINY BLOB、BLOB、MEDIUM BLOB、LONG BLOB

日期类型：Date、DateTime、TimeStamp、Time、Year

其他数据类型：BINARY、VARBINARY、ENUM、SET、Geometry、Point、MultiPoint、LineString、MultiLineString、Polygon、GeometryCollection等

 

使用索引时，有一些技巧：

1.索引不会包含有NULL的列

只要列中包含有NULL值，都将不会被包含在索引中，复合索引中只要有一列含有NULL值，那么这一列对于此符合索引就是无效的。

2.使用短索引

对串列进行索引，如果可以就应该指定一个前缀长度。例如，如果有一个char（255）的列，如果在前10个或20个字符内，多数值是唯一的，那么就不要对整个列进行索引。短索引不仅可以提高查询速度而且可以节省磁盘空间和I/O操作。

3.索引列排序

mysql查询只使用一个索引，因此如果where子句中已经使用了索引的话，那么order by中的列是不会使用索引的。因此数据库默认排序可以符合要求的情况下不要使用排序操作，尽量不要包含多个列的排序，如果需要最好给这些列建复合索引。

4.like语句操作

一般情况下不鼓励使用like操作，如果非使用不可，注意正确的使用方式。like ‘%aaa%’不会使用索引，而like ‘aaa%’可以使用索引。

5.不要在列上进行运算

6.不使用NOT IN 、<>、！=操作，但<,<=，=，>,>=,BETWEEN,IN是可以用到索引的

7.索引要建立在经常进行select操作的字段上。

这是因为，如果这些列很少用到，那么有无索引并不能明显改变查询速度。相反，由于增加了索引，反而降低了系统的维护速度和增大了空间需求。

8.索引要建立在值比较唯一的字段上。

9.对于那些定义为text、image和bit数据类型的列不应该增加索引。因为这些列的数据量要么相当大，要么取值很少。

10.在where和join中出现的列需要建立索引。

11.where的查询条件里有不等号(where column != …),mysql将无法使用索引。

12.如果where字句的查询条件里使用了函数(如：where DAY(column)=…),mysql将无法使用索引。

13.在join操作中(需要从多个数据表提取数据时)，mysql只有在主键和外键的数据类型相同时才能使用索引，否则及时建立了索引也不会使用。

 

索引的类型：

UNIQUE(唯一索引)：不可以出现相同的值，可以有NULL值

INDEX(普通索引)：允许出现相同的索引内容

PROMARY KEY(主键索引)：不允许出现相同的值

fulltext index(全文索引)：可以针对值中的某个单词，但效率确实不敢恭维

组合索引：实质上是将多个字段建到一个索引里，列值的组合必须唯一

 

索引虽然好处很多，但过多的使用索引可能带来相反的问题，索引也是有缺点的：

虽然索引大大提高了查询速度，同时却会降低更新表的速度，如对表进行INSERT,UPDATE和DELETE。因为更新表时，mysql不仅要保存数据，还要保存一下索引文件

建立索引会占用磁盘空间的索引文件。一般情况这个问题不太严重，但如果你在要给大表上建了多种组合索引，索引文件会膨胀很宽

索引只是提高效率的一个方式，如果mysql有大数据量的表，就要花时间研究建立最优的索引，或优化查询语句。

Mysql数据库引擎

Mysql支持三个引擎：ISAM、MYISAM和HEAP。另外两种类型innodb和BERKLEY(BDB)，也常常使用。

MYISAM类型不支持事务处理等高级处理，而innodb类型支持。

MYISAM类型的表强调的是性能，其执行速度比innodb类型更快，

但是不提供事务支持，而innodb提供事务支持以及外键等高级数据库功能。

 

 

事务隔离级别：
四种隔离级别说明

 

隔离级别	脏读	不可重复读	幻读
未提交读	可能	可能	可能
已提交读	不可能	可能	可能
可重复读	不可能	不可能	可能
可串行化	不可能	不可能	不可能

 

Redis

Redis支持五种数据类型：

string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。

 

Redis和memcached区别

1. redis和memcahce都是将数据存放在内存中，都是内存数据库。不过memcache还可用于缓存其他东西，例如 图片、视频等等；
2. redis不仅仅支持简单的k/v类型的数据，同时还提供list,set,hash等数据结构存储；
3. 虚拟内存--redis当物理内存用完时，可以将一些很久没有用到的value交换到磁盘；
4. 过期策略—memcache在set时就指定，例如set key1 0 0 8，即永不过期。Redis可以通过例如expire设定，例如expire name 10；
5. 分布式—设定memcache集群，利用magent做一主多从；redis可以做一主多从。都可以一主多从
6. 存储数据安全—memcache挂掉后，数据没了；redis可以定期保存到磁盘（持久化）；
7. 灾难恢复—memcache挂掉后，数据不可以恢复；redis数据丢失后可以通过aof恢复；
8. Redis支持数据的备份，即master-slave模式的数据备份

 

 

Redis的应用场景都有哪些。

1、缓存

缓存现在几乎是所有中大型网站都在用的必杀技，合理的利用缓存不仅能够提升网站访问速度，还能大大降低数据库的压力。Redis提供了

键过期功能，也提供了灵活的键淘汰策略，所以，现在Redis用在缓存的场合非常多。

2、排行榜

很多网站都有排行榜应用的，如京东的月度销量榜单、商品按时间的上新排行榜等。Redis提供的有序集合数据类构能实现各种复杂的排行榜应用。

3、计数器

什么是计数器，如电商网站商品的浏览量、视频网站视频的播放数等。为了保证数据实时效，每次浏览都得给+1，并发量高时如果每次都请求数据库操作无疑是种挑战和压力。Redis提供的incr命令来实现计数器功能，内存操作，性能非常好，非常适用于这些计数场景。

4、分布式会话

集群模式下，在应用不多的情况下一般使用容器自带的session复制功能就能满足，当应用增多相对复杂的系统中，一般都会搭建以Redis等内存数据库为中心的session服务，session不再由容器管理，而是由session服务及内存数据库管理。

5、分布式锁

在很多互联网公司中都使用了分布式技术，分布式技术带来的技术挑战是对同一个资源的并发访问，如全局ID、减库存、秒杀等场景，并发量不大的场景可以使用数据库的悲观锁、乐观锁来实现，但在并发量高的场合中，利用数据库锁来控制资源的并发访问是不太理想的，大大影响了数据库的性能。可以利用Redis的setnx功能来编写分布式的锁，如果设置返回1说明获取锁成功，否则获取锁失败，实际应用中要考虑的细节要更多。

6、 社交网络

点赞、踩、关注/被关注、共同好友等是社交网站的基本功能，社交网站的访问量通常来说比较大，而且传统的关系数据库类型不适合存储这种类型的数据，Redis提供的哈希、集合等数据结构能很方便的的实现这些功能。

7、最新列表

Redis列表结构，LPUSH可以在列表头部插入一个内容ID作为关键字，LTRIM可用来限制列表的数量，这样列表永远为N个ID，无需查询最新的列表，直接根据ID去到对应的内容页即可。

8、消息系统

消息队列是大型网站必用中间件，如ActiveMQ、RabbitMQ、Kafka等流行的消息队列中间件，主要用于业务解耦、流量削峰及异步处理实时性低的业务。Redis提供了发布/订阅及阻塞队列功能，能实现一个简单的消息队列系统。另外，这个不能和专业的消息中间件相比。

 

Web安全

Xss和CSRF的区别：

(1)CSRF比XSS漏洞危害更高。

(2)CSRF可以做到的事情，XSS都可以做到。

(3)XSS有局限性，而CSRF没有局限性。

(4)XSS针对客户端，而CSRF针对服务端。

(5)XSS是利用合法用户获取其信息，而CSRF是伪造成合法用户发起请求。

 

XSS原理：

XSS又叫CSS(Cross-SiteScripting跨站脚本攻击)为了不和css层叠样式表混淆，所以改成了XSS。

XSS是将恶意的代码插入到html页面中，当用户浏览页面时，插入的html代码会被执行，从而达到最终目的。

 

XSS分为三种：

反射型：这种反射型一般存在链接中，请求链接时，代码经过服务器端就会反射回来。

存储型：一般在留言板、搜索框里会遇到，直接插入到留言板中当用户每次访问时都会反射这种称为存储型。

DOM型：是一种发生在客户端文档对象模型中的跨站漏洞。

以上三种漏洞会造成：身份盗用，钓鱼欺骗、垃圾信息发送等；

 

XSS：修复方式和SQL注入修复方式相同，建议查看历史文章。

 

CSRF：CSRF是跨站请求伪造(Cross-siterequestforgery)大家可能认为和XSS漏洞相似容易混淆，其实和XSS区别还是很大的，

与XSS攻击相比，CSRF攻击不流行（所以防范的资源也稀少）和难以防范，所以被称为比XSS更具危险性。同样这也是XSS和CSRF区别之一。

 

XSS和CSRF攻击的防御

 

XSS攻击可以通过以下两方面操作：

1，对用户表单输入的数据进行过滤，对javascript代码进行转义，然后再存入数据库；

2，在信息的展示页面，也要进行转义，防止javascript在页面上执行。

 

CSRF攻击的防御可以通过以下两方面操作：

1，所有需要用户登录之后才能执行的操作属于重要操作，这些操作传递参数应该使用post方式，更加安全；

2，为防止跨站请求伪造，我们在某次请求的时候都要带上一个csrf_token参数，用于标识请求来源是否合法，csrf_token参数由系统生成，存储在SESSION中。

 

PHP做好防盗链的基本思想 防盗链
什么是盗链？

盗链是指服务提供商自己不提供服务的内容，通过技术手段绕过其它有利益的最终用户界面(如广告)，直接在自己的网站上向最终用户提供其它服务提供商的服务内容，骗取最终用户的浏览和点击率。受益者不提供资源或提供很少的资源，而真正的服务提供商却得不到任何的收益。

网站盗链会大量消耗被盗链网站的带宽，而真正的点击率也许会很小，严重损害了被盗链网站的利益。 如何做防盗链？

不定期更名文件或者目录

限制引用页

原理是，服务器获取用户提交信息的网站地址，然后和真正的服务端的地址相比较， 如果一致则表明是站内提交，或者为自己信任的站点提交，否则视为盗链。实现时可以使用HTTP_REFERER1 和htaccess 文件(需要启用mod_Rewrite)，结合正则表达式去匹配用户的每一个访问请求。

文件伪装

文件伪装是目前用得最多的一种反盗链技术，一般会结合服务器端动态脚本 (PHP/JSP/ASP)。实际上用户请求的文件地址，只是一个经过伪装的脚本文件，这个脚本文件会对用户的请求作认证,一般会检查 Session，Cookie 或HTTP_REFERER 作为判断是否为盗链的依据。而真实的文件实际隐藏在用户不能够访问的地方，只有用户通过验证以后才会返回给用户

加密认证

这种反盗链方式，先从客户端获取用户信息，然后根据这个信息和用户请求的文件名 字一起加密成字符串(Session ID)作为身份验证。只有当认证成功以后，服务端才会把用户需要的文件传送给客户。一般我们会把加密的Session ID 作为URL 参数的一部分传递给服务器，由于这个Session ID 和用户的信息挂钩，所以别人就算是盗取了链接，该Session ID 也无法通过身份认证，从而达到反盗链的目的。这种方式对于分布式盗链非常有效。

随机附加码

每次,在页面里生成一个附加码,并存在数据库里,和对应的图片相关,访问图片时和此附加码对比,相同则输出图片,否则输出404图片

加入水印

 

 

 

 

 

 

PSR编程规范

什么是PSR？

PSR是PHP Standards Recommendation的简称，这个是php-fig组织制定的一套规范。至今，php-fig已经发布了五个规范：

? PSR-0：自动加载标准，2014-10-21该标准已经被废弃，使用PSR-4替代，不再细讲

? PSR-1：基本的编码风格

? PSR-2：编码风格（更严格）

? PSR-3：日志记录器接口

? PSR-4：自动加载

PSR-1

PHP标签：

PHP代码必须放在标签或标签中。

编码：

PHP文件必须使用无BOM的UTF-8编码。

副作用：

一个PHP文件可以定义符号（比如类、函数、常量等），或者执行只有唯一副作用的操作（比如输出结果、处理数据等），但是不能同时做这两件事，尽量是一个PHP文件的功能单一。在操作的时候尽量把变量、类、函数的声明分开，通过include或require文件的方式来使用。

如下不符合规范：

// 改变设置

ini_set('error_reporting', E_ALL);

 

// 加载文件

include "file.php";

 

// 打印输出

echo "\n";

 

// 声明

function foo()

{

    // function body

}

符合规范如下：

// 声明

function foo()

{

    // function body

}

 

// 条件判断

if (! function_exists('bar')) {

    function bar()

    {

        // function body

    }

}

命名空间和类：

命名空间和类必须遵循PSR-4自动加载器标准。

类的名称：

每个类都有自己的命名空间，且都在顶级命名空间下，类名必须使用驼峰式（CamelCase）。

PHP 5.3 及以上，必须使用正式的命名空间，例如：

// PHP 5.3 及以后

namespace Vendor\Model;

 

class Foo

{

}

PHP 5.3一下应该使用Vendor_开头的伪命名空间约定，例如：

// PHP 5.3以下

class Vendor_Model_Foo

{

}

常量：

常量必须全部是用大写，并且使用下划线（_）分开。例如：

namespace Vendor\Model;

 

class Foo

{

    const VERSION = '1.0';

    const DATE_APPROVED = '2012-06-01';

}

类的方法：

类的方法必须使用小写字母开头的驼峰式（camelCase）命名。

PSR-2

PSR-2是对PSR-1的PHP的扩充。

贯彻PSR-1：

使用PSR-2代码标准之前要先贯彻PSR-1的代码标准。

文件和代码行：

PHP文件必须使用Unix风格的换行符（LF， linefeed），最后要有一个空行，仅包含PHP代码的文件而且不能使用PHP关闭标签?>，每行代码不应该超过80个字符，每行末尾不能有空格，每行只能有一条语句，可以在适当的地方添加空行提高代码的阅读性。

不加上?>关闭标签，可以避免意料之外的输出错误，如果加上关闭标签，且在关闭标签后有空行，那么空行会被当成输出，导致意想不到的错误。

缩进：

必须以4个空格为缩进，不能使用制表符（Tab键）缩进。

在不同的编辑器中，空格的渲染效果基本一致，而制表符的宽度各有差异。

关键字：

PHP的关键字必须使用小写，而且true, false, 和 null也必须小写。

命名空间和use声明：

现在，namespace声明之后必须要有一个空行，而且use声明必须放在namespace之后，必须分别使用use引入命名空间，而且use后要有空行，例如：

namespace Vendor\Package;

 

use FooClass;

use BarClass as Bar;

use OtherVendor\OtherPackage\BazClass;

 

// ... additional PHP code ...

类的继承和实现：

extends和implements关键字必须和类名在同一行，类、接口和Traits定义体的起始括号应该在类名之后新起一行，结束括号也必须新起一行，例如：

namespace Vendor\Package;

 

use FooClass;

use BarClass as Bar;

use OtherVendor\OtherPackage\BazClass;

 

class ClassName extends ParentClass implements \ArrayAccess, \Countable

{

    // constants, properties, methods

}

如果implements后面后很多类导致一行很长，可以依次将需要的类另起新行并缩进4个空格，如下：

namespace Vendor\Package;

 

use FooClass;

use BarClass as Bar;

use OtherVendor\OtherPackage\BazClass;

 

class ClassName extends ParentClass implements

    \ArrayAccess,

    \Countable,

    \Serializable

{

    // constants, properties, methods

}

可见性：

类中的每个属性和方法都要声明可见性，有public、private和protected，不能使用var关键词来声明，老版本的PHP会在私有属性前加上_，一行只能声明一个属性，例如：

namespace Vendor\Package;

 

class ClassName

{

    public $foo = null;

}

方法：

类中的所有方法也应该定义可见性，方法名后面不能有空格，方法体的括号位置和类定义体的括号位置一样，都要新起一行，结束括号也要新起一行。方法参数的起始圆括号之后没有空格，结束括号之前也没有空格，有多个参数是，每个参数的逗号后面加一个空格，例如：

namespace Vendor\Package;

 

class ClassName

{

    public function fooBarBaz($arg1, &$arg2, $arg3 = [])

    {

        // method body

    }

}

如果参数比较多，需要换行时，可以如下：

namespace Vendor\Package;

 

class ClassName

{

    public function aVeryLongMethodName(

        ClassTypeHint $arg1,

        &$arg2,

        array $arg3 = []

    ) {

        // method body

    }

}

abstract、final和static：

现在，abstract、final必须在可见性修饰符之前，static声明必须放在可见性修饰符之后，例如：

namespace Vendor\Package;

 

abstract class ClassName

{

    protected static $foo;

 

    abstract protected function zim();

 

    final public static function bar()

    {

        // method body

    }

}

方法和函数的调用：

在调用方法和函数时，圆括号必须跟在函数名之后，函数的参数之间有一个空格：

bar();

$foo->bar($arg1);

Foo::bar($arg2, $arg3);

如果参数比较多，一行放不下时，如下处理：

$foo->bar(

    $longArgument,

    $longerArgument,

    $muchLongerArgument

);

PHP的控制结构：

PHP的控制结构包括if、else、elseif、switch、case、while、do while、for、foreach、try和catch。如果这些关键词后面有一对原括号，开始括号前必须有一个空格，与方法和类的定义体不同，控制结构关键词后面的起始括号应该和控制结构关键词写在同一行，例如：

$gorilla = new \Animals\Gorilla;

$ibis = new \Animals\StrawNeckedIbis;

 

if ($gorilla->isWake() === true) {

    do {

        $gorilla->beatChest();

    } while ($ibis->isAsleep() === true);

    

    $ibis->flyAway();

}

PHP闭包函数：

闭包函数在声明时，function关键词后必须有一个空格，同时use关键词前后也必须有一个空格。起始大括号不需要另起新行，详细的如下代码：

$closureWithArgs = function ($arg1, $arg2) {

    // body

};

 

$closureWithArgsAndVars = function ($arg1, $arg2) use ($var1, $var2) {

    // body

};

闭包函数有多个参数时，处理方式和方法的参数一样：

$longArgs_noVars = function (

    $longArgument,

    $longerArgument,

    $muchLongerArgument

) {

    // body

};

 

$noArgs_longVars = function () use (

    $longVar1,

    $longerVar2,

    $muchLongerVar3

) {

    // body

};

 

$longArgs_longVars = function (

    $longArgument,

    $longerArgument,

    $muchLongerArgument

) use (

    $longVar1,

    $longerVar2,

    $muchLongerVar3

) {

    // body

};

 

$longArgs_shortVars = function (

    $longArgument,

    $longerArgument,

    $muchLongerArgument

) use ($var1) {

    // body

};

 

$shortArgs_longVars = function ($arg) use (

    $longVar1,

    $longerVar2,

    $muchLongerVar3

) {

    // body

};

注意：以上规则同样适用于将闭包作为函数或方法的参数，如下：

$foo->bar(

    $arg1,

    function ($arg2) use ($var1) {

        // body

    },

    $arg3

);

PSR-3

与PSR-1和PSR-2不同，PSR-3规定了一套通用的日志记录器接口（Psr\Log\LoggerInterface），为了符合PSR-3规范，框架必须实现该规范中的接口，这样可以更多的兼容第三方应用。PSR-3规范中包含了9个方法，每个方法都对应了RFC 5424协议的一个日志级别，而且都接受两个参数$message和$context，如下：

 

namespace Psr\Log;

 

/**

 * Describes a logger instance

 *

 * The message MUST be a string or object implementing __toString().

 *

 * The message MAY contain placeholders in the form: {foo} where foo

 * will be replaced by the context data in key "foo".

 *

 * The context array can contain arbitrary data, the only assumption that

 * can be made by implementors is that if an Exception instance is given

 * to produce a stack trace, it MUST be in a key named "exception".

 *

 * See https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md

 * for the full interface specification.

 */

interface LoggerInterface

{

    /**

     * System is unusable.

     *

     * @param string $message

     * @param array $context

     * @return void

     */

    public function emergency($message, array $context = array());

 

    /**

     * Action must be taken immediately.

     *

     * Example: Entire website down, database unavailable, etc. This should

     * trigger the SMS alerts and wake you up.

     *

     * @param string $message

     * @param array $context

     * @return void

     */

    public function alert($message, array $context = array());

 

    /**

     * Critical conditions.

     *

     * Example: Application component unavailable, unexpected exception.

     *

     * @param string $message

     * @param array $context

     * @return void

     */

    public function critical($message, array $context = array());

 

    /**

     * Runtime errors that do not require immediate action but should typically

     * be logged and monitored.

     *

     * @param string $message

     * @param array $context

     * @return void

     */

    public function error($message, array $context = array());

 

    /**

     * Exceptional occurrences that are not errors.

     *

     * Example: Use of deprecated APIs, poor use of an API, undesirable things

     * that are not necessarily wrong.

     *

     * @param string $message

     * @param array $context

     * @return void

     */

    public function warning($message, array $context = array());

 

    /**

     * Normal but significant events.

     *

     * @param string $message

     * @param array $context

     * @return void

     */

    public function notice($message, array $context = array());

 

    /**

     * Interesting events.

     *

     * Example: User logs in, SQL logs.

     *

     * @param string $message

     * @param array $context

     * @return void

     */

    public function info($message, array $context = array());

 

    /**

     * Detailed debug information.

     *

     * @param string $message

     * @param array $context

     * @return void

     */

    public function debug($message, array $context = array());

 

    /**

     * Logs with an arbitrary level.

     *

     * @param mixed $level

     * @param string $message

     * @param array $context

     * @return void

     */

    public function log($level, $message, array $context = array());

}

关于message参数：

$message必须是一个字符串或者是含有__toString()方法的对象，$message应该包含占位符，例如{placeholder_name}，占位符由{、占位符名称和}组成，不能包含空格，占位符名称可以由A-Z, a-z, 0-9, _组成，第三方实现可以用$context参数来替换占位符，占位符名称必须和$context数组的key对应。如下例子是使用$context中的值替换$message中的占位符：

 

/**

 * Interpolates context values into the message placeholders.

 */

function interpolate($message, array $context = array())

{

    // build a replacement array with braces around the context keys

    $replace = array();

    foreach ($context as $key => $val) {

        // check that the value can be casted to string

        if (!is_array($val) && (!is_object($val) || method_exists($val, '__toString'))) {

            $replace['{' . $key . '}'] = $val;

        }

    }

 

    // interpolate replacement values into the message and return

    return strtr($message, $replace);

}

 

// a message with brace-delimited placeholder names

$message = "User {username} created";

 

// a context array of placeholder names => replacement values

$context = array('username' => 'Bolivar');

 

// echoes "User Bolivar created"

echo interpolate($message, $context);

关于context参数：

$context是一个数组参数，用于构造复杂的日志消息，$context中的值不能跑出任何PHP异常或错误。如果$context中包含Exception对象，则该对象的key必须为exception。

PSR-3日志记录器的使用

推荐使用monolog/monolog，这样可以让我们不需要浪费更多的时间在编写一个日志记录器了。Monolog组建完全实现了PSR-3接口，而且便于使用自定义的消息格式化程序和处理程序扩展功能，通过Monolog可以把日志消息写入文本文件、系统日志和数据库中，还能通过电子邮件发送，并且还支持Slack和远程服务器。如下展示了如何设置Monolog，并把日志消息写入文本文件：

use Monolog/Logger;

use Monolog/Handler/StreamHandler;

 

// 创建日志记录器

$log = new Logger('myApp');

$log->pushHandler(new StreamHandler('logs/development.log, Logger::DEBUG));

$log->pushHandler(new StreamHandler('logs/production.log', Logger::WARNING));

 

// 使用日志记录器

$log->debug("This is a debug message");

$log->warning("This is a warning message");

PSR-4

PSR-4规范描述了一个标准的自动加载器策略，指在运行时按需查找PHP类、接口或Traits。支持PSR-4自动加载器标准的PHP组建和框架，使用同一个自动加载器就能找到相关代码，然后将其载入PHP解释器。有了这个功能，就可以把现代PHP生态系统中很多客户操作的组件联系起来。

编写一个PSR-4自动加载器

PSR-4规范不要求改变代码的实现方式，只建议如何使用文件系统目录结构和PHP命名空间组织代码，PSR-4规范以来PHP命名空间和文件系统目录结构查找并加载PHP类、接口和Traits，这正是PSR-4的精髓所在。下面我们来自己手动实现一个PSR-4自动加载器：

/**

 * 使用SPL组册这个自动加载函数后，遇到下述代码时这个函数会尝试   从/path/to/project/src/Baz/Qux.php文件中加载\Foo\Bar\Baz\Qux类：

 *  new \Foo\Bar\Baz\Qux;

 * @param string $class 完全限定的类名。

 * @return void

 **/

spl_autoload_register(function ($class) {

    // 项目的命名空间前缀

    $prefix = 'Foo\\Bar\\';

    

    // 目录前缀对应的根目录

    $base_dir = __DIR__ . '/src/';

    

    // 判断传入的类是否使用了这个命名空间前缀

    $len = strlen($prefix);

    if (strncmp($prefix, $class, $len) !== 0) {

        // 没有使用，交给注册的下一个自动加载器处理

        return;

    }

    

    // 获取去掉前缀后的类名

    $relative_class = substr($class, $len);

    

    // 把命名空间前缀替换成根目录，

    // 在去掉前缀的类名中，把命名空间分隔符替换成目录分隔符，

    // 然后在后面加上.php

    $file = $base_dir . str_replace('\\', '/', $relative_class) . '.php';

    

    // 如果该文件存在，就将其导入

    if (file_exists($file)) {

        require $file;

    }

});