1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//1
HTTP协议是无状态的，数据交换完毕，客户端和服务端的连接就会关闭，使用session和cookie就可以解决，不同是session保存在服务端，cookie保存在客户端。session依赖cookie传递，禁用cookie，不影响session使用，在session的存储文件生成sessionid，通过url传递到session的页面，读取sessionid可以获取session数据。
//2
客户端访问php页面，执行session_start，生成session_id，一般我们是把session_id存储到cookie上，session内容保存在服务端，客户端访问访问不同的页面都会把session_id传到服务端，通过session_id来获取session内容。
产生的背景和原理：
HTTP协议是无状态的协议。一旦数据交换完毕，客户端与服务器端的连接就会关闭，再次交换数据需要建立新的连接。这就意味着服务器无法从连接上跟踪会话。于是需要引入一种机制，COOKIE于是就顺应而生。
Session是另一种记录客户状态的机制，不同的是Cookie保存在客户端浏览器中，而Session保存在服务器上。客户端浏览器访问服务器的时候，服务器把客户端信息以某种形式记录在服务器上。这就是Session。
区别：（位置，大小，安全）
1、Cookie以文本文件格式存储在浏览器中，而session存储在服务端。
2、cookie的存储限制了数据量，只允许4KB，而session是无限制的。
3、cookie和session都可以设置过期时间
4、cookie包含在每一个客户端请求报文中，因此容易被人捕获。
//另一个回答
session存储在服务器端，cookie保存在客户端，session比较安全，
cookie用某些手段修改，不安全。
Session依赖cookie进行传递。禁用cookie后，session还可以使用，在存储session的文件中，生成sessionID，通过get传参的方式将sessionID传到要实现session共享的页面，读取sessionID,从而从session中获取数据

1
2
3
在代码中有10句include，php就要解析10次，而require只需1次。include引入文件前需要判断文件存不存在，如果不存在会提示报错，不影响程序运行。require不需要包含文件，不同的是如果不存在文件，提示报错，程序终止。
require比requir_once效率高。*_once是opcode缓存下调用。*_once需要额外的去查看系统有没有调用过这个文件。

1
2
3
4
5
主键是约束，唯一索引是一种索引；
主键不可以null，唯一索引可以null；
一张表中只有一个主键，但可以有多个索引；
主键可以做外键，唯一索引不可以；

1
2
3
4
HTTP端口是80；HTTPS是443；
HTTPS是要到ca申请证书；
HTTP协议是无状态的，HTTPS是有ssl加密协议http协议构成的，进行的是加密传输，身份认证的协议；

1
2
3
4
5
6
1XX类状态码信息表示：临时的响应。
2XX类状态码信息表示：服务器已成功接收，理解和接受请求
3XX类状态码信息表示：重定向。
4XX类状态码信息表示：请求错误。
5XX类状态码信息表示：服务器遇到错误

1
2
3
事务是可以将逻辑相关的一组操作绑定在一起；
事务的特性：原子性：要么全做，要么全部做；一致性；持续性/永久性：事务一旦提交对数据库的数据的改变是永久性的；隔离性：一个事务的执行不会被其他事务干扰；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//使用array_unique(array);
$arr = [12,1,12,1,456,789];
var_dump(array_unique($arr));
//使用array_flip(array);
$arr = [12,1,12,1,456,789];
$a
= array_flip($arr);
$b
= array_flip($a);
var_dump($b);
//键值互换使用
$result_01 = array_flip($input);
$result= array_key($result_01);
var_dump($result);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
$arr = array(
array("name" => "a"),
array("name" => "b"),
array("name" => "c"),
array("name" => "b"),
array("name" => "c"),
array("name"=> "d"),
["name"=>"c"],
["name"=>"d"]
);
$key = "name";
$result = array_unique_new($arr,$key);
function array_unique_new($arr,$key){
$temp_arr = array();
foreach($arr as $k => $v){
if(in_array($v[$key],$temp_arr)){
unset($arr[$k]);
}else{
$temp_arr[$k] = $v[$key];
}
}
return $arr;
}

1
2
3
4
5
function Directory($dir = '/'){
return is_dir($dir) or Directory(dirname($dir)) and mkdir($dir,0777);
}
Directory("upload");

1
2
php运行一个类时，当前脚本没有这个类后者没有手动引入这个类文件时，php会自动调用_autoload($class_name)函数,该函数有一个参数，这个参数就是类的名称；

1
2
3
4
5
6
7
8
9
10
11
12
function writeData($filepath, $data){
$fp = fopen($filepath,'a');
do{
usleep(100);
}while (!flock($fp,LOCK_EX));
$res = fwrite($fp, $data."n");
flock($fp, LOCK_UN);
fclose($fp);
return $res;
}
writeData("index_txt.txt","sda");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
function xf_dir($path){
$files = [];
if($h = opendir($path)){
//打开文件
while( ($file = readdir($h)) !== false ){
//循环读取
if($file != '.' && $file != '..'){
//除 .
..
if(is_dir($path.'/'.$file)){
//如果是文件按文件名保存
$files[$file] = xf_dir($path.'/'.$file);	//递归保存
}else{
$files[] = $path.'/'.$file;
}
}
}
}
closedir($h);
//关闭文件
return $files;
}

1
2
3
4
5
6
7
$a = "hello";
$b = &$a;
unset($b);
$b = "world";
echo $a;
//hello

1
2
3
4
5
6
7
$a = 1;
$x = &$a;
$b = $a++;
echo $b;
//1
赋值完$b之后$a才++

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
function clear_dir($path){
if(is_dir($path)){
//是否有文件
$p = scandir($path);	//查找该文件下的所有文件
foreach($p as $val){
if($val != '.' && $val != '..'){	//除. ..
if(is_dir($path.'/'.$val)){
//判断是不是文件
clear_dir($path.'/'.$val);	//递归删除这个文件的下的所有目录
rmdir($path.'/'.$val);	//删除当前文件
}else{
unlink($path.'/'.$val);	//删除当前文件
}
}
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

$a = '/a/b/c/d/e/f/g/h/e.php';
$b = '/a/b/1/2/c.php';
function getRelativePath($a, $b){
$relativePath = "";
$pathA = explode("/", dirname($a));
$pathB = explode("/", dirname($b));
$n = 0;
$len = count($pathB) > count($pathA) ? count($pathA) : count($pathB);
do{
if( $n >= $len || $pathA[$n] != $pathB[$n]){
break;
}
}while(++$n);
$relativePath .= str_repeat("../", count($pathB) -$n);
$relativePath .= implode("/", array_splice($pathA, $n));
return $relativePath;
}

1
2
3
4
5
6
7
8
create table message(
id int AUTO_INCREMENT PRIMARY KEY,
title char(20) NOT NULL,
content varchar(255) NOT NULL,
category_id int NOT NULL,
hits int
)engine=innoDB default charset=utf8;

1
2
3
4
文章id 文章标题 点击量 回复数量
用一个SQL语句完成上述查询，如果文章没有回复则回复数量显示为0
:select m.id,m.title,m.hits,(select count(*) from comment c where m.category_id=c.id) as num from message m order by num desc;

1
2
3
4
5
category_id int(4) not null auto_increment;
categroy_name varchar(40) not null;
用户输入文章时，通过选择下拉菜单选定文章分类
写出如何实现这个下拉菜单[可使用PHP,JAVASCRIPT,HTML]

1
2
3
4
session共享的思路:
1，让客户端访问同一个sessionid
2，让所有域名对应的服务器访问的session的数据的位置必须一致

1
2
3
4
5
<?php if ('1e3' == '1000') echo 'LOL'; ?>	//B
A 无任何输出结果 　　　　B
LOL 　　　　　　C 不执行且报错
//1e3 是 科学计数法 实数的指数形式 为1乘以10的三次方

1
2
3
4
5
6
7
<?php $a = "aabbzz"; $a++; echo $a; ?>
//C
A b 　　　　　　　　　　　B aabbzz 　　　　　　　　　　C aabcaa
/***
字符串字母相加其实就是在末尾字母加一 如：$a = "a"; $a++;答应结果就是 b,$a=''aa';结果就是ab 故$a = "aabb";打印结果就是 aabc ,如$a = "aabbz";结果就是 aabca,因为Z是末尾字母故加一变为a,向前一位进一,b就变为c,故结果为C；
**/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<?php
$data = ['a','b','c'];
foreach($data as $k => $v){
$v = &$data[$k];
}
var_dump($data);	//['b','c','c']
>
A $data = ['a','b','c']; B $data = ['b','b','c']; C $data = ['b','c','c'];
/***
这里有个考点要记得 就是&是引用；修改引用变量的值，那么空间的值也会改变，
第一次循环 得到
$v = &$data[0]=>'a',
//此时$v 和 $data[0] 是同一存储空间
第二次循环
$v = &$data[1]=>'b',
//将b的值给$v（$data[0]）
//并$v引用的$data[1]同一存储空间,
可见第一次引用的$data[0]的值已经被改变，所以此时的$data[0]=b,此时$v引用的$data[1],
进入第三次循环 此时$v又变为
$v = &$data[2]=>'c',
//将c的值给$v（$data[1]）
//并$v引用的$data[2]同一存储空间,
所以此时的$data[1]=c,
这样循环结束
$data[0]=>'b'， $data[1]=>'c'， $data[2]=>'c'，
**/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php
$a = 0.1;
$b = 0.7;
if($a+$b == 0.8){
//0.79999999
echo true;
}else{
echo false;
//PHP不能进行浮点数计算，CPU在计算浮点数时，先转换成二进制，导致值不正确。
};
A 空; 　　　　B true;
　　C false; 　　　D、1；　　E、0；　　F:报错	// A
/***
这里的考点有两个：
1，echo false和true的值；
2、浮点类型不能用于精确计算；首先浮点类型的数据不能用于计算，他会将浮点类型转为二进制，所以有一定的损耗，故它无限接近于0.8，也就是0.79999999...，所以echo 应该是个false；echo false；结果是空；echo true；结果是1；
***/
// $a = 9223372036854775807;
// $b = 9223372036854775808;
// var_dump($a === ($b - 1));
>

1
2
3
4
echo $_SERVER['REMOTE_ADDR']; //客户端IP
echo gethostbyname("www.baidu.com");
//服务端IP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$a= 0;$b= 0;
if($a = 3>0 || $b = 3>0){
//a = true
$a++;
$b++;
}
echo $a.','.$b;
/****
A报错；　　　　B:1,1;
(要是真的只有两个选项该多好肯定大家都选B)
解析：此题考查的是运算符的优先级问题，首先在此题中比较运算符>逻辑运算符>赋值，
所以1，先看 3>0为true,
2，因为是||运算所以后面的$b=3>0 形成短路作用，这时的$a=true,$b=0;
　　故$a++;为1；$b++;为1这里解释下布尔类型运算不影响布尔类型结果；但是$b=0;$b++;就改变为1， echo true；结果为1，
***/

1
2
3
4
orm:对象关系映射。是一种程序技术，用于面向对象编程与不同类型的数据库之间的转换。
n+1:执行一次查询N条主数据，又执行n次查询从数据，带来不必要的查询开销。
处理：可以通过orm自带的with去解决。

1
2
3
4
5
6
7
1，DNS解析，将输入的url解析为IP地址。
2，建立tcp连接，根据ip地址与服务器进行连接通信。
3，发送请求，请求相关资源。
4，服务器收到请求并返回报文，并带上指定的资源。
5，浏览器解析资源渲染页面。
6，tcp关闭连接。

1
2
requset:用来获取请求信息。 response：用来设置响应消息

1
2
3
4
索引：普通索引；唯一索引；主键索引；组合索引；
优势：提高数据的检索速度，减低排污的成本；
劣势：占用存储空间，降低更新数据的速度；

1
2
3
经常用到查询条件的字段，经常需要排序，分组，统计的字段；
与其他表关联的字段

1
2
3
4
经常增删改的表不要建立索引；
频繁更新的字段；
表的记录太少；

1
2
3
4
5
redis的落地是持久化；
有两种策略：
1:RDB:定时快照方式；
2:AOF:基于语句追加文件的方式；

1
2
3
4
5
6
字符串类型：string
队列：list
散列：hash
集合：set
有序集合：zset

1
2
3
4
5
6
7
getstr($str){
$arr = parse_url($str);
$dir = basename($arr['path']);
$ext = explode('.',$dir);
return $ext[1];
}

1
2
3
4
1.弱类型
2.网络
3.cpu

1
2
3
4
5
6
7
8
9
10
简要的过程如下：
1. PHP是随着Apache的启动而运行的；
2. PHP通过mod_php5.so模块和Apache相连（具体说来是SAPI，即服务器应用程序编程接口）；
3. PHP总共有三个模块：内核、Zend引擎、以及扩展层；
4. PHP内核用来处理请求、文件流、错误处理等相关操作；
5. Zend引擎（ZE）用以将源文件转换成机器语言，然后在虚拟机上运行它；
6. 扩展层是一组函数、类库和流，PHP使用它们来执行一些特定的操作。比如，我们需要mysql扩展来连接MySQL数据库；
7. 当ZE执行程序时可能会需要连接若干扩展，这时ZE将控制权交给扩展，等处理完特定任务后再返还；
8. 最后，ZE将程序运行结果返回给PHP内核，它再将结果传送给SAPI层，最终输出到浏览器上。

1
2
https://learnku.com/docs/psr

1
2
3
4
5
6
7
8
tp6只能通过composer安装；
类的加载方式：tp5采用的自己一套实现记载方式，tp6采用的是composer类的加载方式
tp6有严格模式，tp5没有；
tp6支持更多的psr规范
组件的独立
中间件改进：tp6使用管道模式来时间中间件，比tp5的更加简洁
引入filesystem组件

1
2
3
4
5
6
7
8
9
1, 入口文件。
2，加载应用。
3，注册服务。
4，生成事件。
5，加载中间件。
6，解析路由。
7，执行控制器方法。
8，响应输出。

1
2
3
4
1.查询条件尽量使用数组方式。
2.使用预处理机制。
3.开启字段类型验证。

1
2
3
4
5
6
7
8
9
10
1 强大的rest router:用简单的回调函数就可以调用,快速绑定controller和router
2 artisan:命令行工具,很多手动的工作都自动化
3 可继承的模板,简化view的开发和管理
4 blade模板:渲染速度更快
5 ORM操作数据库
6 migration:管理数据库和版本控制
7 测试功能也很强大
8 composer也是亮点
9 laravel框架引入了门面,依赖注入,Ioc模式,以及各种各样的设计模式等

1
2
3
laravel框架是使用了服务组件化的开发模式，由多个服务提供者构成了组件，再由多个组件提供不同的服务，然后是多个服务构成了项目
服务提供者是应用配置的核心，是通过 register方法中绑定服务到服务容器的。

1
2
3
4
5
6
7
8
9
laravel框架使用了大量设计模式，使模块之间耦合度很低，服务容器可以方便的扩展框架功能以及编写测试。
1.ORM - 对象关系映射模式
2 依赖注入与IOC容器 - 策略模式
3 监听与触发
-
观察者模式
4 门面模式 - 静态代理
还有其他的，比如注册服务的时候用到单例模式等。

1
2
3
能快速开发出功能，自带各种方便的服务，比如数据验证、队列、缓存、数据迁移、测试、artisan 命令行等等，还有强大的 ORM，artisan强大的命令行工具，实现自动化。
Laravel安全功能有效地利用了盐散列和加密码机制，Bcrypt哈希算法”来创建加密密码。

1
2
3
4
5
6
服务容器：是一个用于管理类依赖和执行依赖注入的强大工具。其实质是通过构造函数或者某些情况下通过「setter」方法将类依赖注入到类中。
门面：为应用服务容器中的绑定类提供了一个「静态」接口 ，优点：在维护时能够提供更加易于测试、更加灵活、简明优雅的语法。
契约：用来规划服务提供者的格式、方法、参数等，给服务提供者规范了一定约束。
反射：主要用来动态地获取系统中类、实例对象、方法等语言构件的信息，通过发射API函数可以实现对这些语言构件信息的动态获取和动态操作等。
后期静态绑定：用于在继承范围内引用静态调用的类，即在类的继承过程中，使用的类不再是当前类，而是调用的类。

1
2
3
4
5
6
7
8
入口文件-
请求web服务器导入这个文件-
载入 Composer 生成的自动加载启动核心文件-
内核启动(服务提供者启动框架的各种组件)-
交给路由分发到到（控制器，中间件等）-
逻辑处理-
返回结果