0%

Web安全学习——PHP

发表于 更新于 分类于
本文字数： 26k 阅读时长 ≈ 23 分钟

PHP语法结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#标准风格
<?php
    echo "hello php";
?>
 
#短风格,需要修改php.ini中的 hort_open_tag = On 选项，重启服务器生效
<?
    echo "hello php";
?>
 
#ASP风格，需要修改php.ini中的asp_tags = On 选项，重启服务器生效
<%
    echo "hello php";
%>
 
#长风格
<script language='php'>
    echo "hello php";
</script>

PHP注释

1
2
3
4
5
6
7
<?php
    #单行注释 shell风格
    //单行注释  C++风格
    /*
    多行注释 C风格
    */
?>

PHP变量

1
2
3
4
5
<?php
	#变量的声明及赋值
	$user_name = "小明";
	$a=$b=$c=12; #一次声明多个变量，并且赋值相同值
?>

变量特性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?php
 
	#PHP可变变量
	$a = "b";
	$b = "c";
	$c = "d";
	echo $$$a;   #输出"d"    $$a = #b = "c"   $$$a = $c = "d"  等量交换
 
	#变量的赋值，不同变量分别开辟不同内存空间，互不影响
	$a=1;
	$b=$a;
	$a=2;
	echo $a,$b  #分别输出2和1
 
	#&符号为取地址符，表示该变量指向其他变量的内存地址，2个变量共享一个内存空间，其中一个变量修改了值会影响另一个变量值
	$a=1;
	$b=&$a;
	$a=2;
	echo $a,$b  #分别输出2和2
?>

数据类型

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
<?php
 
	#PHP数据类型分为8种主要数据类型，3种伪类型：
 
	#标量类型：
	#1、整形（包括：十进制、八进制、二进制）
	$int = 1;
	$int = -1;
	$int = 0x123;
	var_dump($int);  #var_dump()函数打印变量的详细信息  输出 int(291)
 
	#2、浮点型
	$float = 1.2;
	var_dump($float); #float(1.2)
	$float = 2e3; #float(2000)
	var_dump($float);
 
	#3、布尔型（True和False）
	$bool = True;
	var_dump($bool); #bool(true)
	$bool = False;
	var_dump($bool); #bool(false)
 
	#4、字符串（单引号、双引号、HereDoc、NowDoc）
	$string = "hello";
	var_dump($string); #string(5) "hello"    在UTF-8中，一个中文占3个长度
	$string = 'hello';
	var_dump($string); #string(5) "hello" 
 
	#复合数据类型
	#5、数组
	$array = array();
	var_dump($array); #array(0) { }
 
	#6、对象
	$object = new stdClass();
	var_dump($object); #object(stdClass)#1 (0) { }
 
	#特殊类型
	#7、资源
	$handle = fopen('index.php','r');
	var_dump($handle); #resource(3) of type (stream)
 
	#8、空(未声明变量的值为NULL，声明变量并且赋值为NULL，用unset()函数注销过的变量)
	$a = NULL;
	$b = 1;
	unset($b);
 
	#伪类型
	#1、数值型(number)
	#2、混合类型(mixed)
	#3、回调函数(callback)
?>

字符串特性

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
28
29
30
31
32
33
34
35
36
37
38
<?php
 
	#单引号和双引号的区别：
 
	#1、双引号解析变量、单引号不解析变量
	$name="hello php";
	echo $name; #hello php
	echo "$name"; #hello php
	echo '$name'; #$name
 
	#2、因为单引号不解析变量，故单引号执行效率高
 
	#3、双引号会解析所有转义字符，单引号只能解析\\和\'两个转义字符
	$string = "hello \n\t\'\" php";
	echo $string; #hello \'" php
	$string = 'hello \n\t\'\" php';
	echo $string; #hello \n\t'\" php
 
	#4、双引号包含单引号会解析变量，单引号包含双引号不解析变量
	$str='hello';
	echo "'$str'"; # 'hello'
	echo '"$str"'; # "$str"
 
	#5、使用花括号{}进行变量与字符串的连接
	$str='hello';
	echo "{$str}s"; # hellos
	echo "${str}s"; # hellos
 
	#6、使用花括号对字符串中的值进行增删改查
	$str='hello';
	echo $str{2}.'<hr>'; #查找字符 输出l
	$str{2}='f'; #修改字符,只能替换一个字符，如果赋值多个字符，则会取第一个字符
	echo $str.'<hr>'; # heflo
	$str{9}='f'; #增加字符，没有对应的字符会用空格进行填充
	echo $str.'<hr>'; #heflo f
	$str{0}=''; #删除字符
	echo $str.'<hr>'; #eflo f
?>

大文本字符串

1
2
3
4
5
6
7
8
<?php
	#大文本适合php代码和hmtl、js代码混合使用的时候，不用考虑字符串单双引号的烦恼。
	$name = 'hello php';
	$str = <<<EOD
	hello {$name}
	EOD;
	echo $str; #hello hello php
?>

数据类型转换-隐式转换（自动转换）

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
28
29
30
31
32
33
34
35
36
37
<?php
 
	#一、其他类型转换为数值型：
	#1、布尔类型转换成数值型 True转为1，False转换为0
	echo True #1
	echo 1+False #1
 
	#2、null空类型转换数值型为0
	echo 1+NULL; #1
 
	#3、字符串类型转换为数值型，如果不是以数字开头的字符串，转换为0，如果是以数字开始的字符串，截取到非法数字结束为止
	echo 1+'a'; #1
	echo 1+'1'; #2
	echo 1+'2a'; #3
	echo 1+'2a11'; #3
	echo 1+'2.1abc'; #3.1
	echo 1+'2e2'; #201
 
	#二、其他类型转换成字符串型
	#1、数值类型转换为字符串类型为数值本身
	echo 123; #123
 
	#2、布尔类型转换成字符串型，True为'1'，False为空字符串
	echo True; #1
	echo Fasle; #空字符串
 
	#3、NULL转换成字符串型为空字符串
	echo NULL; #空字符串
 
	#三、其他类型转换为布尔型，只需记住为假的即可，其他的都为真：
	#空字符串''和""、字符串'0'/"0"
	#0
	#0.0
	#null
	#空数组
 
?>

数据类型转换-强制转换（显示转换）

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
28
29
30
31
32
33
34
35
36
37
38
<?php
	#临时转换，格式(数据类型)变量/值：
	#(int)、(float)、(double)、(bool)、(string)、(unset)、(array)、(object)
	var_dump((int)'123'); #int(123)
	var_dump((float)20); #float(20)
	var_dump((string)123); #string(3) "123"
	var_dump((bool)1); #bool(true)
 
 
	#临时转换，通过函数进行转换：intval()、floatval()、strval()、boolval()
	var_dump(intval('123')); #int(123)
	var_dump(floatval(123)); #float(123) 
	var_dump(strval(123)); #string(3) "123"
	var_dump(boolval('1')); #需要使用php5.5.0以上
 
 
	#永久转换，设置变量类型：settype($var,$type)，获取变量类型gettype($val)
	$var =123;
	echo settype($var,int); #1
	var_dump($var); #int(123) 
	echo settype($var,float); #1
	var_dump($var); #float(123)
	echo settype($var,bool); #1
	var_dump($var); #bool(true)
 
 
	#检测变量类型： is_数据类型($var)
	$var =123;
	var_dump(is_int($var)); #bool(true)
	var_dump(is_float($var)); 
	var_dump(is_string($var));
	var_dump(is_bool($var)); 
	var_dump(is_double($var)); 
	var_dump(is_array($var)); 
	var_dump(is_object($var));
	var_dump(is_null($var));
	var_dump(is_numeric($var));
?>

系统常量、自定义常量和魔术常量

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
<?php
 
	#一、系统常量，PHP内置好的常量，直接调用即可
	echo PHP_VERSION; #PHP版本  5.4.45
	echo PHP_OS; #操作系统类型  WINNT
	echo M_PI; #3.1415926535898
 
	#二、自定义常量 define($name,$value,[是否不区分大小写])
	define('PI','3.1415'); #常量名最好全部大写
	define('MY_AGE',20);
	echo PI; #3.1415
	echo MY_AGE; #20
	echo my_age; #Notice: Use of undefined constant my_age  
	define('AGE',22,True); #设置为True,不区分
	echo AGE; #22
	echo age; #22
 
	#通过constant()函数获取常量值
	echo constant('AGE'); #22
 
	#通过defined()函数检测常量是否被定义
	var_dump(defined('AGE')); #bool(true)
	var_dump(defined('my')); #bool(false)
 
	#结合以上进行常量判断定义与取值
	$name='NAME';
	$value='zhangshan';
	if(!defined($name)){
    	echo "常量未被定义";
    	define($name,$value);
    	echo $name; #输出NAME  
    	echo constant($name); #输出zhangsan，所以这里要用constant()函数进行获取常量值
	}else {
    	echo constant($name);
	}
 
 
	#在PHP5.3后可以使用const进行定义常量  const 常量名=值
	const ROOT='root';
	echo ROOT; #root
	echo constant('ROOT'); #root
 
	#通过get_defined_constants()函数得到已定义的所有常量
	print_r(get_defined_constants());
	/*
	Array
	(
    	[E_ERROR] => 1
    	[E_RECOVERABLE_ERROR] => 4096
    	[E_WARNING] => 2
    	[E_PARSE] => 4
    	[E_NOTICE] => 8
    	[E_STRICT] => 2048
    	........
	*/
 
 
 
	#三、PHP魔术常量
	echo __LINE__; #文件中当前的行号    3
	echo __FILE__; #文件的绝对路径和文件名 			D:\phpStudy\PHPTutorial\WWW\BJ\index.php
	echo __DIR__; #返回文件所在目录 D:\phpStudy\PHPTutorial\WWW\BJ
	__FUNCTION__; #返回函数名称    
	__CLASS__; #返回类名称
	__NAMESPACE__; #返回当前命名空间的名称
	#等等其他
?>

运算符

  • 算术运算符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?php
    echo 1+1; #2
    echo 3-2; #1
    echo 2*2; #4
    echo 4/2; #2
    echo 5%2; #1
 
    #自增运算
    $int1 = 2;
    echo $int1++; #2  先执行，再加1
    echo $int1; #3
    $int1 = 2;
    echo ++$int1; #3   先加1，在执行
    echo $int1; #3
 
    #自减运算
    $int1 = 2;
    echo $int1--; #2
    echo $int1; #1
    $int1 = 2;
    echo --$int1; #1
    echo $int1; #1
?>
  • 字符连接符
1
2
3
4
5
6
7
8
9
10
<?php
    #通过.符号连接2个字符串或字符串变量
    echo 'hello'.'world'; #helloworld
    echo 'hello','world'; #helloworld
    $name='php';
    echo '<hr>';
    echo 'hello'.$name; #hellophp
    echo '<hr>';
    echo 'helo',$name; #hellophp
?>
  • 赋值运算符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php
    #赋值运算符包括 =、+=、-=、*=、/=、%=、.=
    $a=1;
    echo $a+=1; #2 $a=$a+1  1+1=2
    echo $a-=1; #1 $a=$a-1  2-1=1
    echo $a*=1; #1 $a=$a*1  1*1=1
    echo $a/=1; #1 $a=$a/1  1/1=1
    #.=的运用，输出2行表格
    $table='<table border="1">';
        $table.='<tr>';
            $table.='<td>a</td>';
            $table.='<td>a</td>';
        $table.='</tr>';
    $table.='</table>';
    echo $table;
?>
  • 比较运算符
1
2
3
4
5
6
7
8
<?php
    #比较运算符包括 >、>=、<、<=、==、!=、<>、===、!==
    var_dump(2>1); #bool(true)
    var_dump(2<1); #bool(false)
    # ==与===区别：==只比较值是否相同，===(全等于)值和类型都要相同
    var_dump(1==1,1=='1',1==True); # bool(true) bool(true) bool(true)
    var_dump(1===1,1==='1',1===True); #bool(true) bool(false) bool(false)
?>
  • 逻辑运算符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?php
    #逻辑运算符包括 逻辑与(and或&&)、逻辑或(or或||)、逻辑非(!)、逻辑异或(xor)
 
    #逻辑与 and && 全部为真，返回真  短路的现象：第一个表达式为假，则返回假，不运算其他表达式
    var_dump(True and True); #bool(true)
    var_dump(True && False); #bool(false)
 
    #逻辑或 or || 只要有一个为真，返回真    短路现象：第一个表达式为真，则返回真，不运算其他表达式
    var_dump(True or True); #bool(true)
    var_dump(True || False); #bool(true)
 
    #逻辑非 取反
    var_dump(!True); #bool(false)
 
    #逻辑异或 xor 两个表达式同为True或者False，返回False
    var_dump(True xor False); #bool(true)
    var_dump(True xor True); #bool(false)
 
?>
  • 执行运算符
1
2
3
4
5
<?php
    #执行运算符 ``反引号作为shell命令来执行,与shell_exec()作用相同
    print_r(`cd`); #D:\phpStudy\PHPTutorial\WWW\BJ
    print_r(shell_exec('cd')); #D:\phpStudy\PHPTutorial\WWW\BJ
?>
  • 错误抑制符
1
2
3
4
5
<?php
	#错误抑制符@，加到错误表达式之前
	echo 4/0; #Warning: Division by zero in
	echo @(4/0); #不会显示警告信息
?>
  • 三元运算符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php
    #三元运算符 exp1?exp2:exp3  exp1为真，返回exp2，否则返回exp3
    $a=3>2?'True':'False';
    echo $a; #True
    #等同于
    if(3>2){
        echo 'True';
    }else {
        echo 'False';
    }
 
    #三元运算符 exp1?:exp2  exp1为真，返回exp1，否则返回exp2
    $a=3>2?:'False';
    var_dump($a); #bool(true)
?>

流程控制

  • if语句
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
<?php
    #IF语句第一种形式 if
    if(True){
        echo 'hello world<br />';
        echo 'php is if';
    }
 
    #IF语句第二种形式 if-else
    if(True){
        echo 'True';
    }else {
        echo 'False';
    }
 
    #IF语句第三种形式  if-elseif-else
    $int1 = 5;
    if($int1 === 1){
        echo '1';
    }elseif($int1 ===2){
        echo '2';
    }elseif($int1 ===3){
        echo '3';
    }else{
        echo 'hello';
    }
 
    #获取星期几例子   输出 2018年09月01日 14:58:52星期六
    header('content-type:text/html;charset=utf8'); #有中文，设置编码
    echo @date('Y年m月d日 H:i:s'); #加上错误抑制符@，就不会显示日期警告
    $a = @date('w');
    if($a === '1'){
        echo '星期一';
    }elseif($a === '2'){
        echo '星期二';
    }elseif($a === '3'){
        echo '星期三';
    }elseif($a === '4'){
        echo '星期四';
    }elseif($a === '5'){
        echo '星期五';
    }elseif($a === '6'){
        echo '星期六';
    }elseif($a === '0'){
        echo '星期日';
    }else{
        echo '错误';
    }
?>
  • 预定义变量
    • _POST：接收表单以POST方式发送的数据
    • _GET：接收以?形式传参的数据
    • _FIFES：文件上传变量
    • _SERVER：服务器和执行环境变量
    • _ENV：环境变量
    • _SESSION：会话变量
    • COOKIE：HTTP Cookie
    • REQUEST：$_GET+$_POST+$_COOKIE
    • GLOBALS：超全局变量，在全部作用域中始终可用的内置变量
    • $php_errormsg：前一个错误信息
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
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>POST、GET和REQUEST例子</title>
</head>
<body>
    <form action="" method="post">
        姓名：<input type="text" name="name" id="">
        <input type="submit" name="submit" value="提交">
    </form>
    <a href="http://127.0.0.1/bj/index.php?name=php">GET提交</a>
    <?php
        if(isset($_POST['submit'])){ #使用isset()函数，检测变量是否被设置值
            $name=$_POST['name'];
            echo '欢迎'.$name;
        }
        if(isset($_GET['name'])){
            echo '欢迎'.$_GET['name'];
        }
        echo $_REQUEST['name'];
    ?>
</body>
</html>
  • switch语句
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
28
29
30
31
32
33
34
35
36
37
38
39
40
<?php
    /*
    switch(exp){
        case 值1:
            代码段;
            break;
        case 值2:
            代码段;
            break;
        default:
            代码段;
            break;
    }
     */
    header('content-type:text/html;charset=utf-8');
    $date=@date('w');
    switch($date){
        case '1':
            echo '星期一';
            break;
        case '2':
            echo '星期二';
            break;
        case '3':
            echo '星期三';
            break;
        case '4':
            echo '星期四';
            break;
        case '5':
            echo '星期五';
            break;
        case '6':
            echo '星期六';
            break;
        default:
            echo '星期日';
            break;
    }
?>
  • for循环
1
2
3
4
5
6
7
8
9
10
<?php
    for($i=1;$i<10;$i++){
        echo '<br />';
        for($j=1;$j<=$i;$j++){
            echo $j.'*'.$i.'='.$i*$j."  ";
        }
    }
    #continue：跳过本次循环，继续下次循环
    #break：跳出循环
?>
  • while循环
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?php
    $i=1;
    while($i<10){
        $j=1;
        echo '<br />';
        while($j<=$i){
            echo $j.'*'.$i.'='.$i*$j.'  ';
            $j++;
        }
        $i++;
    }
 
    #do-while循环，无条件执行一次循环体代码
    do{
        echo 'aaaa';
    }while(False)
?>

数组

  • 创建数组
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
<?php
 
#一、通过array()函数声明数组
    $array1=array(); //声明一个空数组
    var_dump($array1); //array(0) { }
    echo gettype($array1); //array
    var_dump(is_array($array1)); //bool(true)
    $array2=array(1,2.3,'hello','name'=>'php'); //定义混合数组
    var_dump($array2); //数组下标从0开始，数组分为索引数组和关联数组
    /*
  array(4) {
  [0]=>
  int(1)
  [1]=>
  float(2.3)
  [2]=>
  string(5) "hello"
  ["name"]=>
  string(3) "php"
}
     */
 
#二、动态创建数组  连续索引数组
     $array1[]=1;
     $array1[]=3.14;
     $array1[]='aaa';
     var_dump($array1);
    #手动指定数组下标
    $array2[0]=1;
    $array2[1]=3.14;
    $array2[2]='aaa';
    var_dump($array1);
    #动态创建关联数组
    $arr1['name']='xiaoming';
    $arr1['age']=20;
    $arr1['sex']='男';
    $arr1[]=2;
    var_dump($arr1);
 
#三、快速创建索引数组
    $arr=range(1,10);
    var_dump($arr); //array(10) { [0]=> int(1) [1]=> int(2) [2]=> int(3) [3]=> int(4) [4]=> int(5) [5]=> int(6) [6]=> int(7) [7]=> int(8) [8]=> int(9) [9]=> int(10) }
    
    $arr1=range(1,10,2); //指定步长
    var_dump($arr1); //array(5) { [0]=> int(1) [1]=> int(3) [2]=> int(5) [3]=> int(7) [4]=> int(9) }
    
    #通过compact()函数快速创建关联数组
    $name='xiaoming';
    $age=20;
    $addr='CQ';
    $arr1=compact('name','age','addr');
    print_r($arr1); //Array ( [name] => xiaoming [age] => 20 [addr] => CQ )
?>
  • 使用数组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
 
#对数组进行增删改查
 
$arr['name']='php';
$arr['age']=20;
$arr['addr']='CQ'; //增：
echo $arr['name'];  //查： 通过指定键名获取键值  php
$arr['name']='PHP';  //改： 对数组内元素进行修改，只需要覆盖以前的键值即可
echo $arr['name']; //PHP
unset($arr['name']);  //删：使用unset()函数删除数组元素
print_r($arr);
unset($arr); //删除整个数组
?>
  • 多维数组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?php
    #使用array()函数创建多维数组
    $arr=array(
        array(1,2,3),
        array(4,5,6)
    );
    print_r($arr); //Array ( [0] => Array ( [0] => 1 [1] => 2 [2] => 3 ) [1] => Array ( [0] => 4 [1] => 5 [2] => 6 ) )
    #使用动态创建多维数组
    $arr1[0]['dd']='php'; //创建一个二维数组
    $arr1[0]['name']='hello';
    print_r($arr1); 
    /*
    Array
(
    [0] => Array
        (
            [dd] => php
            [name] => hello
        )
)
    */
    echo $arr1[0]['name'];  //取值
?>
  • 遍历数组
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
<?php
    #格式为：foreach($array as key=>value)
    $arr1[]='aaa';
    $arr1[]='bbb';
    $arr1[]='ccc';
    $arr1[]='ddd';
    foreach($arr1 as $key){ //只取key键名
        echo $key.'<br />';
    }
    /*
aaa
bbb
ccc
ddd
    */
 
    $arr2['name']='PHP';
    $arr2['age']=20;
    $arr2['addr']='CQ';
    foreach($arr2 as $key=>$value){ //取key和value
        echo $key.'=>'.$value.'<br />';
    }
    /*
name=>PHP
age=>20
addr=>CQ
    */
 
 
    #生成二维数组
    $arr1[]=array('name'=>'php','age'=>20,'addr'=>'CQ');
    $arr1[]=array('name'=>'C++','age'=>18,'addr'=>'SH');
    $arr1[]=array('name'=>'JAVA','age'=>29,'addr'=>'CD');
    print_r($arr1);
    /*
    Array
(
    [0] => Array
        (
            [name] => php
            [age] => 20
            [addr] => CQ
        )
    [1] => Array
        (
            [name] => C++
            [age] => 18
            [addr] => SH
        )
    [2] => Array
        (
            [name] => JAVA
            [age] => 29
            [addr] => CD
        )
)
    */
    foreach($arr1 as $key=>$value){ //遍历二维数组
        echo $value['name'].'<br />';
        echo $value['age'].'<hr />';
    };
?>
  • 数组运算符
    • +：合并数组，如果都有相同的键则取左边的
    • ==：具有相同的键值则为True
    • ===：具有相同的键值且类似和顺序都相同则为True
    • !=：具有不相同的键值则为True
    • !==：具有不相同的键值且类似和顺序都相同则为True
1
2
3
4
5
6
<?php
    $arr1=array(1,2,3,4);
    $arr2=array('aa','bb');
    $arr3=$arr1+$arr2;
    print_r($arr3); //Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 )
?>

系统函数

  • 字符串函数

    • 长度：strlen($String) 得到字符串长度
    1
    echo strlen('hello你好'); //11 在UTF-8中，一个中文占3个长度
    • 字符串查找：strpos($string,​$serch[,$offset]) 在指定字符串中查找目标字符串第一次出现的位置
    1
    echo strpos('hello','l'); //2
    • 字符串查找：stripos($string,$serch[,$offset]) 忽略大小写的去查找
    1
    echo stripos('heLlo','l'); //2
    • 字符串替换：str_replace($search,​$replace,$string) 替换字符串 str_ireplace()：忽略大小写进行替换
    1
    echo str_replace('a','1','aaabbbccc'); //111bbbccc
    • 字符串大小写转换：strtolower() 到小写、strtoupper() 到大写
    1
    2
    echo strtolower('ABC'); //abc
    echo strtoupper('abc'); //ABC
    • 字符串截取：substr($string,​$start[,$length]) 截取指定长度字符串
    1
    2
    echo substr('abcdefg',3); //defg
    echo substr('abcdefg',3,2); //de
    • 字符ASCII：ord() chr()
    1
    2
    echo ord('a'); //97
    echo chr(98); //b
    • 加密：md5()、sha1()
    1
    2
    echo md5('admin'); //21232f297a57a5a743894a0e4a801fc3
    echo sha1('admin'); //d033e22ae348aeb5660fc2140aec35850c4da997

    • 字符串过滤

      • trim() 删首尾空
      1
      echo trim(' a bc ');  //a bc
      • strip_tags() 过滤字符串中HTML标记
      1
      echo strip_tags("<html><h1>hello</h1></html>"); //hello
      • addslashes() 使用反斜线引用字符串中特殊字符
      1
      echo addslashes("a'");  //a\'
      • htmlentities() 
      1
      echo htmlentities('<script>alert(/"xs"/)</script>'); //&lt;script&gt;alert(/&quot;xs&quot;/)&lt;/script&gt;gt
      • nl2br() 将字符串中的\n用<br/>代替
      1
      echo nl2br("hello\nworld"); //hello<br />world

    • 字符串比较：strcmp() 比较两个字符串大小

    1
    echo strcmp('aaa','bbb'); //-1
    • 分割文本：expload($delimiter,$string) 将指定字符串拆分为数组
    1
    print_r(explode('#','aaa#bbb#ccc')); //Array ( [0] => aaa [1] => bbb [2] => ccc
    • 合并文本：join($delimiter,$array) 将数组连接成字符串
    1
    2
    $arr1=array('aaa','bbb','ccc');
    echo join('-',$arr1); //aaa-bbb-ccc
    • 反转字符：strrev()
    1
    echo strrev('abc'); //cba

  • 数学函数

    • 求绝对值：abs($number)
    • 四舍五入：round($number,$percision)
    • 幂运算：pow($base,$exp)
    • 平方根：sqrt($number)
    • 求最大值：max($va1,$va2……)
    • 求最小值：min($va1,$va2……)
    • 产生随机数：mt_rand($min,$max)

  • 日期时间函数

    • 得到当前时间戳：time()
    1
    echo time();//1535887462
    • 得到当前服务器时间：date($format[,$time])
    1
    echo date('Y-m-d'); //2018-09-02

自定义函数

  • 定义函数
1
2
3
4
5
6
7
<?php
    #函数的定义
    function fun1($int1,$int2){
        return $int1+$int2;
    }
    echo fun1(3,5); //函数的调用
?
  • 函数的参数
1
2
3
4
5
6
7
8
9
<?php
    #函数的参数分为2种：形参和实参
    #形参有2种：必选参数和可选参数
    function fun1($str1,$str2='php'){
        return $str1.' '.$str2;
    }
    echo fun1('hello'); //hello php
    echo fun1('hello','world'); //hello world
?>
  • 变量的作用域
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php
    #变量的作用域分为：局部变量和全局变量
    #局部变量又分为：动态变量和静态变量
    function test(){
        $i=1; //局部动态变量,函数执行完就释放
        $i++;
        echo $i.'<br/>';
        static $a=1; //局部静态变量，函数执行完保存在静态内存中
        $a++;
        echo $a.'<br/>';
    }
    test(); //2 2
    test(); //2 3
    test(); //2 4
 
    $str1='php';
    function test1(){
        global $str1;  //函数内不能直接调用全局变量，如果要使用，进行global关键字实现
        echo $str1; //php
    }
    test1();
?>
  • 传值和传引用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php
    #传值在函数体内对变量更改不影响变量本身
    #传引用在函数体内对变量更改影响变量本身
    $str1='php';
    function test($str){
        $str='hello';
        echo $str; //hello
    }
    test($str1);
    echo $str1; //php    直接传值，不会影响原变量
 
    function test1(&$str){
        $str='hello';
        echo $str; //hello
    }
    test1($str1);
    echo $str1; //hello   传引用，会影响变量本身
?>
  • 变量函数
1
2
3
4
5
6
7
8
9
10
11
<?php
    #将函数名称赋值给变量，调用的时候通过变量名称加上小括号的形式进行调用
    $md51='md5';
    echo $md51('admin');  //21232f297a57a5a743894a0e4a801fc3
 
    function test(){
        echo 'hello php';
    }
    $test1='test';
    $test1(); //hello php
?>
  • 回调函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
    #自定义回调函数
    function test($str){
        echo 'hello '.$str;
    }
    function callback($call,$str1){
        $call($str1);
    }
    callback('test','php'); //hello php  把函数当作参数传递
 
    #使用call_user_func()进行调用
    call_user_func('test','php'); //hello php
    
?>
  • 递归函数
1
2
3
4
5
6
7
8
9
10
11
<?php
    #函数自己调用本身
    function test($i){
        echo $i.'<br />';
        $i++;
        if($i<=10){ //递归函数一定要有结束条件
            test($i);
        }
    }
    test(1); //输出1 2 3 4 5 6 7 8 9 10  和循环类似
?>
  • 匿名函数
1
2
3
4
5
6
7
<?php
    #匿名函数也叫闭包函数，允许临时创建一个不指定名称的函数
    $test=function($str1){
        echo 'hello '.$str1;
    };
    $test('php');  //匿名函数使用变量函数来进行调用  hello php
?>
  • 可变参数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php
    #func_num_args() 得到函数参数个数
    #func_get_arg()  得到函数参数
    #func_get_args()  得到函数参数数组形式
    function test(){
        echo func_num_args();  //5
        echo func_get_arg(1);  //2  参数下标和数组一样，从0开始
        $arr1=func_get_args(); //Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 )
        foreach($arr1 as $key){
            echo $key;  //12345 得到每个参数值
        }
    };
    test(1,2,3,4,'5'); 
 
?>

类的定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?php
    #类的属性：就是在类中定义的变量
    #类的方法：就是在类中定义的函数
    class Peoole{  //类的定义用class关键字进行描述
        public $name='PHP'; //类的属性值只能是值，不能是变量、函数、对象等
        public $age=20;
        public $height=170;
        public function eat($food){ //类的方法和函数类似
            echo 'eat'.$food;
        }
        public function sleep(){
            echo 'sleep....';
        }
    }
    $peoole1=new Peoole(); //实例化类  用new关键字实例化出一个对象
    echo $peoole1->name; //访问对象中的属性或方法 用->符号进行
    $peoole1->eat('Apple');
    $peoole1->sleep();
    $peoole1->name='java';  //也可以修改对象的属性值
?>

$this的作用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?php
    #在类中，通过$this访问自身属性和方法
    class class1{
        public $name='php';
        public $age=20;
        function fun1(){
            echo 'fun1...';
        }
        function fun2(){
            echo $this->name; //php
            echo $this->age; //20
            $this->fun1(); //fun1
        }
    }
    $a=new class1();
    $a->fun2();
?>

构造函数与析构函数

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
    header('content-type:text/html;charset=utf-8');
    class class1{
        public $name;
        public $age;
        function __construct($name,$age){ # #构造函数：实例化对象时，首先会调用构造函数，适合初始化
            $this->name=$name;
            $this->age=$age;
            echo '构造函数被执行了<br />';
        }
        function __destruct(){ ##析构函数：当对象所有引用被删除或销毁前之前被调用 （可以通过析构函数释放结果集、资源、关闭连接等）
            echo '析构函数被执行了<br />';
        }
        function test(){
            echo $this->name.'<br />';
            echo $this->age.'<br />';
        }
    }
    $p1=new class1('PHP',20);
    $p1->test();
    /* 
构造函数被执行了
PHP
20
析构函数被执行了
    */
?>

封装之访问修饰符

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
28
29
<?php
	/*
	#封装性：外部只能调用或访问部分开放的属性和方法，不知道内部具体实现细节
	  访问控制符：
		public：公有的
		protected：受保护的,不能被外部访问，可由子类访问
		private：私有的，只能自己类访问，不能通过继承访问
	*/
   class class1{
	   public $name;
	   protected $age;
	   private $addr;
	   function __construct($name,$age,$addr){
		   $this->name=$name;
		   $this->age=$age;
		   $this->addr=$addr;
	   }
	   function test(){
		   echo $this->name.'<br .>'; //在类中可以访问受限制的属性
		   echo $this->age.'<br .>';
		   echo $this->addr.'<br .>';
	   }
   } 
   $p1=new class1('php',20,'CQ');
   $p1->test(); //php 20 CQ
   echo $p1->name; //php  在外部,只能访问公有的属性
   echo $p1->age; // 在外部，不能访问类中受限制的属性    Fatal error: Cannot access protected property class1::$age
   echo $p1->addr; //Fatal error: Cannot access private property class1::$addr
?>

__get和__set魔术方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php
	#__get() 当在类外部对私有的或受保护的或未定义的成员属性进行读取时会被调用
	#__set() 当在类外部对私有的或受保护的或未定义的成员属性进行赋值时会被调用
	class class1{
		public $name='php';
		protected $age=20;
		private $addr='CQ';
		public function __get($var_name){
			echo 'this is __get()';
			return $this->$var_name;
		}
		public function __set($var_name,$var_value){
			echo 'this is __set()';  
			$this->$var_name=$var_value;
		}
	}
	$p1=new class1();
	//echo $this->age; //在类外部不能直接访问类中受限或私有的属性
	echo $p1->age;  //this is __get() 20
	$p1->age=18; //this is __set()
	echo $p1->age; //this is __get() 18
?>

__isset()和__unset()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?php
    //可利用此魔术方法限制不可销毁或检测的属性
    header('content-type:text/html;charset=utf-8');
    class class1{
        private $name='php';
        private $age=20;
        private $addr='CQ';
        public function __isset($var_name){
            echo '当类外部调用isset()或empty()检测不可访问的属性或未定义的属性时自动调用此函数';
            return isset($this->$var_name);
        }
        public function __unset($var_name){
            echo '当类外部调用unset()函数销毁不可访问的属性或未定义的属性时自动调用此函数';
            unset($this->$var_name);
        }
    }
    $p1=new class1();
    isset($p1->name); //当类外部调用isset()或empty()检测不可访问的属性或未定义的属性时自动调用此函数
    isset($p1->ddddd); //当类外部调用isset()或empty()检测不可访问的属性或未定义的属性时自动调用此函数
    unset($p1->name); //当类外部调用unset()函数销毁不可访问的属性或未定义的属性时自动调用此函数
?>

继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?php
    #子类可以继承父类的属性和方法，但是PHP是单继承
    class Person{  //定义一个父类
        public $name;
        public $age;
        public function __construct($name,$age){
            $this->name=$name;
            $this->age=$age;
        }
        public function getinfo(){
            echo $this->name.'----'.$this->age;
        }
    }
    class Person1 extends Person{  //使用关键字extends继承父类
        public $addr='CQ';  //子类可以自己增加属性
        public function test(){
            echo $this->name.'--'.$this->age.'--'.$this->addr;  //子类可以调用父类的属性和方法
        }
    }
    $p1= new Person1('PHP',20);
    echo $p1->name; //PHP    子类可以使用父类的可访问属性和方法
    $p1->test(); //PHP--20--CQ  字类也可以在父类的基础上进行扩展
?>

parent关键字的作用

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
28
29
30
31
32
33
<?php
    ##parent::属性名/方法
    class Person{
        public $name;
        public $age;
        public function __construct($name,$age){
            $this->name=$name;
            $this->age=$age;
        }
        public function getinfo(){
            return $this->name.'--'.$this->age;
        }
    }
    class Person1 extends Person{
        public $addr='CQ';
        public function getinfo(){
            return $this->name.'--'.$this->age.'--'.$this->addr;
        }
        public function getinfo1(){
            $str=parent::getinfo(); 
/*
parent::getinfo()等同于 return $this->name.'--'.$this->age.'--'.$this->addr;
*/
 //如果在子类中有与父类重复调用的代码，可以用parent关键字代替
            return $str.'--'.$this->addr;
        }
 
    }
    $p1=new Person1('PHP',20);
    echo $p1->getinfo().'<br />';  //PHP--20--CQ
    echo $p1->getinfo1();  //PHP--20--CQ
 
?>

final关键字的作用

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
<?php
    #。如果父类中的方法被声明为 final，则子类无法覆盖该方法。如果一个类被声明为 final，则不能被继承。
    class class1{
        final public function test(){
            echo 'hello world';
        }
    }
    class class2 extends class1{
        public function test(){ //如果在父类的方法定义了final，在子类中则不能覆盖该方法
            echo 'hello php';
        }
    }
    $p1=new class1();
    $p1->test();
 
    $p2=new class2();
    $p2->test(); //Fatal error: Cannot override final method class1::test()
 
    final class class3{
        public $name='aaa';
    }
    class class4 extends class3{ //Fatal error: Class class4 may not inherit from final class (class3) i
 
    }
    $p3=new class3();
?>

继承中可见性分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?php
    #在继承中，父类的private私有的修饰符属性和方法， 不能被子类继承。
    class class1{
        public $name='php';
        protected $age=20;
        private $addr='CQ';
    }
    class class2 extends class1{
        public function test(){  //子类继承父类时，不能访问父类的private私有属性和方法
            echo $this->name; //php
            echo $this->age; //20
            echo $this->addr;  //Notice: Undefined property: class2::$addr
        }
    }
    $p1=new class2();
    $p1->test();
 
    #在继承中，子类覆盖父类属性和方法时，不能比父类修饰时严格
    #父类如果是public 子类只能为public  父类是private 子类可以为public和protected
    class class3 extends class1{
        private $name='php1'; //php1  
        public $addr='AAA'; //Fatal error: Access level to class3::$name must be public (as in class class1)
    }
?>

类中static关键字的使用和调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?php
    /*
    在类中，访问静态属性和方法，不能使用$this来访问。
    1、在类中，使用static关键字修饰的属性和方法，不能通过$this来使用，只能使用
    类名::属性/方法
    seif::属性/方法
    2、在类中，使用static关键字修饰的方法中，不能含有$this
    */
    class A{
        static public $name='PHP';
        public $age=20;
        public function test(){
            //echo $this->name;   //在类中，访问static修饰的属性和方法，不能使用$this调用  Strict Standards: Accessing static property A::$name as non static
            echo self::$name; //PHP  只能使用seif::属性/方法
        }
        static public function test1(){
            //echo $this->age;  //在static修饰的方法中，不能使用$this   Fatal error: Using $this when not in object context
        }
    }
    $p1=new A();
    $p1->test();
    $p1->test1();
    echo A::$name;  //PHP   在类外部，可以不通过实例化对象，使用类名::属性/方法来调用
?>

后期静态绑定 static::属性/方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php
    #self::属性/方法  表示当前父类中的属性和方法
    #static::属性/方法  表示当前类中的属性和方法
    class A{
        static public $name='PHP';
        public function test(){
            echo self::$name;  //PHP
            echo static::$name; //JAVA
        }
    }
    class B extends A{
        static public $name='JAVA';
    }
    $p1=new B();
    $p1->test();
?>

类常量-const

1
2
3
4
5
6
7
8
9
10
11
12
<?php
    #在类中，使用const关键字定义 “常量属性”
    #注意，定义和使用常量不需要加$符号
    class A{
        const PI=3.14;
        public function test(){
            echo self::PI;  //3.14
        }
    }
    $p1=new A();
    $p1->test();
?>

抽象类-abstract

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?php
    #1、定义的抽象类不能被实例化，只能通过子类继承实现
    #2、任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的
    #3、被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现
    #4、继承一个抽象类的时候，子类必须定义父类中的所有抽象方法
    abstract class A{
        public function test(){
            echo 'test....';
        }
        abstract public function test1();
    }
    //$p1=new A();  //抽象类不能实例化  Fatal error: Class A contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (A::test1)
    class B extends A{
        public function test1(){  //继承一个抽象类的时候，子类必须定义父类中的所有抽象方法
            echo 'bbbbb';
        }
    }
    $p2=new B();
?>

对象接口

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
<?php
/*
    1、接口和抽象类类似，定义的方法，子类必须实现。
    2、使用interface定义接口，使用implements关键字实现接口
    接口必须public公开
    3、一个类可以实现多个接口
    4、接口可以继承另外的接口，及继承多个接口
*/
 
interface A{  //定义一个接口 使用interface关键字
    public function test();  //定义接口的方法，和抽象类一样，不需要实现方法具体内容
    public function test1($name);  //接口也可以定义属性
}
class class1 implements A{  //定义一个类实现接口A 使用implements关键字
    public function test(){  //必须实现接口中定义的方法
        echo 'A接口中的test方法';
    }
    public function test1($name){
        echo 'A接口中的test1方法'.$name;
    }
}
 
interface B{
    public function test2();
}
class class1 implements A,B{   //一个类可以实现多个接口
    public function test(){
        echo 'A接口中的test方法';
    }
    public function test1($name){
        echo 'A接口中的test1方法'.$name;
    }
    public function test2(){
        echo 'B接口中的test2方法';
    }
}
 
interface C extends A,B{  //接口可以继承另外的接口，及继承多个接口
    public function test4();
}
?>