首页 > > 网络编程 > Php编程 >

PHP基础

2018-06-22 05:37:30来源：未知 阅读 ()

新老客户大回馈,云服务器低至5折

 测试模板

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>测试</title>
</head>
<body>
    <!-- 下面所有代码都放在body里面测试 -->
    <!-- 该模板放于D:\Apache24\htdocs文件夹下 -->
    <!-- 并命名为index.html -->
    <!-- 在浏览器地址栏里直接输入localhost打开 -->
    
</body>
</html>
  • 默认语法
<?php
    echo "<p>修抗</p>";
?>
  • 短标签
<?
    print "修抗";
?>

开启短标签需要打开php.ini,将 Off 修改为 On ，重启服务器才能正常使用

 

短路语法

<?="修抗";?>

这与下面两种形式功能是相同的

<? echo "修抗"; ?>
<?php echo "修抗"; ?>
  • 嵌入多个代码块

 PHP代码与非PHP代码可以多次交替出现

<?php
    echo "修抗1";
?>
<p>修抗2</p>
<?php
    print "修抗3";
?>
  • 如果PHP代码在最后，结束标签可以省略
<?php
    echo "修抗";

PHP乱码问题

  • 通过meta标签
<meta charset="UTF-8">
<?php
    echo "修抗";
?>

为代码添加注释

  • 单行C++语法
<?php
    //单行注释
    echo "修抗";
?>
  • shell语法
<?php
    #单行注释
    echo "修抗";
?>
  • 多行C语法
<?php
    /*
    多行注释1
    多行注释2
    */
    echo "修抗";
?>

PHP中的输出语句

  • print()语句

 下面三个都是print()语句

<?php
    print ("<p>修抗1</p>");
?>

<?php
    $xiu = "2";
    print ("<p>修抗 $xiu</p>");
?>

<?php
    print ("<p>修
    抗3</p>");
?>

正式语法要求使用括号把参数括起来，但也可以省略括号，因为从技术上讲，print()并不是一个函数，而是一个语言结构

print()语句无论结果是什么，这个函数总是返回1

  • echo()语句

可以使用echo()达到print()的目的

 echo()可以输出多个字符串

<?php
    $xiu = "修抗1";
    $kang = "修抗2";
    echo $xiu,"与",$kang;
    //输出结果为：修抗1与修抗2 
?>

echo()比print()的速度快一点，原因：echo()什么都不返回，而print()输出成功要返回1

  • printf()语句

printf()将静态数据与动态数据清晰的分至到两个不同的部分

printf()可以决定如何将信息显示到屏幕，可控因素包括类型，精度，对齐方式，和位置

<?php
    printf("修 %d 抗",110);
    //输出为：修 110 抗 
?>

%d是一个称为类型指示符的占位符，

  • 常用的类型指示符：

%b　　将参数认为一个整数，显示为二进制数

%c　　将参数认为一个整数，显示对应的ASCII字符

%d　　将参数认为一个整数，显示为有符号的十进制数

%f　　将参数认为一个浮点数，显示为浮点数

%o　　将参数认为一个整数，显示为八进制数

%s　　将参数认为一个字符串，显示为字符串

%u　　将参数认为一个整数，显示为无符号的十进制数

%x　　将参数认为一个整数，显示为小写的十六进制数

%X　　将参数认为一个整数，显示为大写的十六进制数

如果想传入两个值，只需要想字符串插入两个指示符，并确保将两个值作为参数插入

<?php
    printf("修 %d 抗 %f",13,13.14);//输出结果为 修 13 抗 13.140000,保留六位小数，四舍五入
?>

处理小数值时，可以使用一精度指示符调整精度

<?php
    printf("%.1f",13.15); //保留一位小数,输出结果为13.2，四舍五入
?>
  • sprintf()语句

 sprintf()函数功能与printf()相同，但是它必须输出必须赋给一个字符串，而不能直接呈现在浏览器中

<?php
    $xiu = sprintf("修抗");
    echo $xiu;
    //输出为：修抗
?>

PHP支持的数据类型

数据类型（datatype）是一组相同特性的数据的统称

常见的数据类型有：布尔型，整型，浮点型，字符串型和数组

  • 标量数据类型

 标量（scalar）数据类型的变量能够表示单项信息

标量数据类型有：布尔型，整型，浮点型和字符串型

布尔型：

布尔类型只有两个值： true(真) false(假)，数字0表示false，非0表示true

<?php
    $xiu = false; //$xiu为false
    $xiu = 1; //$xiu为true
    $xiu = -1; //$xiu为true
    $xiu = 5; //$xiu为true
    $xiu = 0; //$xiu为false
?>

整型：

 整数就是不包含小数部分的数，PHP支持十进制，八进制，十六进制

<?php
    520 //十进制
    -1314 //十进制
    0755 //八进制
    0xc4e //十六进制
?>

PHP支持的最大整数与PHP平台有关，比如：PHP5支持 ±231，而PHP6支持 ±263

<?php
    echo PHP_INT_MAX;//输出最大整数
?>

浮点型：

 浮点数也称单精度数（float），双精度数（double）或实数（realnumber）

<?php
    echo 3.14159 ."<br/>"; //3.14159
    echo 3.0 ."<br/>"; //3
    echo 8.7e4 ."<br/>"; //87000
    echo 1.23E+11 ."<br/>"; //123000000000
?>

."<br/>"  表示拼接一个换行

字符串：

 字符串就是一个连续的字符序列，通常用单引号或双引号界定

PHP将字符串看做数组，允许通过数组的偏移记法访问特定的字符，比如：

<?php
    $xiu = "hello";
    $kang = $xiu[1];
    echo $kang; //输出e
?>
  • 复合数据类型

 复合数据类型表示将多个相同的类型的项聚集起来，表示一个实体，这包括数组（array）和对象（object）

数组：

 

 

 

 

 

  • 使用类型强制转换实现数据间的转换

 数组（array），对象（object），字符串（string），整数（ing/integer），布尔值（boolean/bool），浮点数（float单精度小数/double双精度小数/real实数）

将整数转换为双精度数

$xiu = (double)13; //$xiu = 13.0

将双精度数转换为整数

$xiu = (int)13.6 //$xiu = 13 ,向下取整，就是不考虑小数点后面的数

将字符串转换为一个整数

<?php
    $xiu = "修抗";
    $kang = (int)$xiu;
    echo $kang; //输出为0
?>

将数据类型转换为数组

这个适用于新创建的数组的第一个成员，如果强制转换到一个存在的数组，会将原数组清空

<?php
    $xiu = "修抗";
    $kang = (array)$xiu;
    echo $kang[0]; //输出为修抗
?>

任何数据类型都可以转换为对象

<?php
    $xiu = "修抗";
    $kang = (object)$xiu;
    echo $kang->scalar; //输出为"修抗"
?>
  • 类型自动转换

 看下面列子：

<?php
    $xiu = "2"; //字符串
    $kang = 3; //整数
    $xiu += $kang; //$xiu = 5 （整数）
?>

 

<?php
    $xiu = "1.0"; //字符串
    if($xiu){
        echo "将字符串转换为布尔值";
    }
?>
  • 与类型相关的函数

 获取类型：

gettype()函数返回var所指定变量的类型，共8个可能返回值

array，boolean，double，integer，object，string与unknown type

<?php
    $xiu = "修抗"; 
    echo gettype($xiu);//返回string
?>

转换类型：

 settype()将var指定的变量转换为type指定的类型，type有7个可取值

array，boolean，float，integer，null，object和string

<?php
    $xiu = "修抗";
    settype($xiu,"boolean"); //将字符串转换为布尔值
?>
  • 类型标识符函数

 is_array()，is_bool()，is_float()，is_int-eger()，is_null()，is_numeric()，is_object()，is_resource()，is_scalar()和is_string()

如果var属于该类型，就返回true，否则返回false

<?php
    $xiu = "修抗";
    echo is_string($xiu);//返回1，错误不返回
?>

标识符

标识符（identifier）是变量，函数和其他各种用户定义对象通用的术语

标识符必须以字母或下划线开头

标识符只能由字母，数字，下划线和129-255的ASCII字符组成

标识符区分大小写

标识符不能与PHP预定义的关键字相同，（预定义的关键字在PHP手册的附录查看）

变量

  • 变量声明

 变量必须以 $ 开头

变量区分大小写

变量名需遵守标识符的命名规则

按值赋值：

$color = "red";
$number = 3.14;
$sum = 3 + "2";//$sum=5

引用赋值：两种方式

<?php
    $xiu = "修";
    $kang =& $xiu;//$xiu和$kang的值都为"修"
    $kang = "抗";//$xiu和$kang的值都为"抗"
?>

 

<?php
    $xiu = "修";
    $kang = &$xiu;//$xiu和$kang的值都为"修"
    $kang = "抗";//$xiu和$kang的值都为"抗"
?>
  • 变量作用域

局部变量：

在函数中声明的变量叫局部变量

<?php
    $xiu = 5;
    function kang(){
        $xiu = 3;
        echo $xiu;
    }
    kang();//输出3
    echo $xiu;//输出5
?>

kang()函数内的$xiu是局部变量，所以修改局部变量$xiu时，不会对函数外部的任何值造成影响

函数参数：

函数参数在函数名后面的括号内声明

声明参数的函数内部可以访问和处理这些函数参数，函数执行结束时，参数就会被取消

<?php
    function xiu($kang){
        $kang++;
        return $kang;
    }
    xiu(2);//输出3
?>

（。。。）

全局变量：

与局部变量相反，全局变量可以在程序任何地方访问，在变量前面加一个global，可以将局部变量转换为全局变量

<?php
    $xiu = 520;
    function xiu(){
        //如果取消global，则最终结果为1,因为局部声明将隐含设置为0
        global $xiu;
        $xiu++;
        return $xiu;
    }
    echo xiu();//输出521
?>

静态变量：

函数参数在函数退出时会被取消，而静态变量在函数退出时不会丢失值，并且还能保存这个值便再次调用

在变量面前加上关键字static就可以声明一个静态变量了

<?php
    function xiu(){
        static $xiu = 0;//如果取消static，则每次输出都为1
        $xiu++;
        return $xiu;
    }
    echo xiu();//输出1
    echo xiu();//输出2
    echo xiu();//输出3
?>

（。。。）

  • PHP的超级全局变量

 输出Web服务器与脚本执行环境有关的所有预定义变量

<?php
    foreach($_SERVER as $var=>$value){
        echo "$var => $value <br/>";
    }
?>

 获取第一条信息

<?php
    echo $_SERVER["HTTP_ACCEPT"];//输出"text/html, application/xhtml+xml, image/jxr, */* "
?>

更多关于服务器和客户的内容：

$_SERVER超级全局变量包含由Web服务器创建的信息

客户的IP地址

$_SERVER["REMOTE_ADDR"]

引导用户到达当前位置的页面URL

$_SERVER["HTTP_REFERER"]

URL的部分路径，比如URL是http://www.xiukang,com/apache/index.html,那么URL就是apache/index.html

$_SERVER["REQUEST_URI"]

用GET方法 获取传递的变量：

 $_GET超级全局变量包含用GET方法传递的参数的有关信息

如果请求URL：http://www.xiukang.com?cat-apache&id=520

就可以使用$_GET超级全局变量访问如下变量

$_GET["cat"] = "apache";
$_GET["id"] = "520";

默认情况下，要访问通过GET方法传递的变量，$_GET超级全局变量是唯一的途径

（。。。）

用POST方法获取传递的变量 ：

 $_POST

<form action="index.html" method="POST">
    <input type="text" name="user"/>
</form>
//通过目标脚本text.php，就可以使用下面的POST变量
<?php
    $_POST["user"] = "xk";
?>

跟$_GET一样，$_POST超级全局变量是唯一访问通过PSOT方法传递的变量

获取存储在cookie中的信息：

 $_COOKIE超级全局变量存储了通过HTTP cookie传递到脚本的信息，

cookie一般是由以前执行的PHP脚本通过PHP函数setcookie()设置的，比如：

使用setcookie()存储的一个名为xiukang.com，值为1234的cookie，可以通过调用$_COOKIE["xiukang.com"]来获取这个值

（。。。）

用POST获取关于上传文件的信息：

 $_FILES超级全局变量包含通过POST方法向服务器上传的数据的有关信息

它是一个二维数组，包含五个元素，第一个下标表示表单的文件上传元素名，第二个下标是五个预定义下标之一，描述了上传文件的某个属性

<?php
    $_FILES["upload-name"]["name"];//从客户端到服务端上传的文件名
    $_FILES["upload-name"]["type"];//上传文件的MIME类型，这个变量是否被赋值取决于浏览器的功能
    $_FILES["upload-name"]["size"];//上传文件的大小（单位字节）
    $_FILES["upload-name"]["tmp_name"];//上传文件后，将此文件移到最终位置之前赋予的临时名
    $_FILES["upload-name"]["error"];//上传状态码
?>

上传状态码有五个可能的值

UPLOAD_ERR_OK 文件上传成功

UPLOAD_ERR_INT_SIZE 文件大小超出了upload_max_filesize指令所指的最大值

UPLOAD_ERR_FORM_SIZE 文件大小超出了MAX_FILE_SIZE隐藏表单域参数指定的最大值

UOLOAD_ERR_PARTIAL 文件只上传了一部分

UPLOAD_ERR_NO_FILE 上传表单中没有指定的文件

（。。。）

更多关于操作系统环境的内容：

 $_EVN超级全局变量提供PHP解析器所在服务器环境有关的信息

$_EVN["HOSTNAME"]; //服务器主机名
$_EVN["SHELL"]; //系统shell

获取存储在会话里的信息：

 $_SESSION超级全局变量包含所有会话变量有关信息

注册会话信息能为你提供便利，而无需GET或POST显示的传递数据

（。。。）

  • 变量的变量
<?php
    $xiu = "abc";
    $$xiu = "def";//将abc赋值一个变量def，
    echo $abc;//输出 "def"
?>

常量

常量是在程序中无法修改的值

定义常量：

define()函数通过给一个变量名赋值来定义一个常量

<?php
    define("PI",3.141592);
    echo PI*3;
?>

常量是全局变量

常量引用前面不需要美元符号$

定义了常量就不能重新定义或取消已定义的常量

表达式

 表达式（expression）是一个短语，表达式至少由一个操作数和一个或以上的操作符组成

<?php
    $a = 5; //将整数值5赋值给变量$a
    $a = "xiu"; //将字符串值"xiu"赋值给$a
    $sum = 520 + $max; //将520+$max的和赋值给$sum
    $xiu++; //变量$xiu加1
?>
  • 操作数

 操作数（operand）是表达式的输入

<?php
    $a++; //$a是操作数
    $sum = $a + $b; //$sum,$a和$b是操作数
?>
  • 操作符

操作符优先级：

操作符优先级（operator precedence），PHP遵循小学算数课所用的标准优先级规则

$sum = $a + $a * 3;
//等价于
$sum = $a + ($a * 3);

操作符综合性：

操作符的综合性（associativity）指定了相同优先级运算的计算顺序

综合性可有两个方向，

从左往右

$sum = 2 * 3 * 4 * 5;
//等价于
$sun = (((2*3)*4)*5);

从右往左

$c = 5;
$var = $a = $b = $c;
//等价于
$var = ($a = ($b = $c));

算数操作符：

$a + $b; //加法
$a - $b; //减法
$a * $b; //乘法
$a / $b; //除法
$a % $b; //取模 $a除于$b的余数

赋值操作符：

$a = 5; //赋值
$a += 5; //加法赋值 $a = $a + 5
$a -= 5; //减法赋值 $a = $a - 5
$a *= 5; //乘法赋值 $a = $a * 5
$a /= 5; //除法赋值 $a = $a / 5
$a .= 5; //拼接赋值 $a = $a5

字符串操作符：

$val = "ab"."cd"; //拼接 $val = abcd
$val .= "abc"; //拼接赋值 $val = $val abc

自增和自减操作符：

++$a，$a++（自增，$a+1）

--$a，$a--（自减，$a-1）

//后自增，先赋值在自增
$a = 3;
$b = $a++;
echo $b; //$b = 3
//前自增，先自增，在赋值
$x = 3;
$y = ++$x;
echo $y; //$y = 4

逻辑操作符：

$a && $b //与 $a和$b都为true时，输出true
$a AND $b //与 $a和$b都为true时，输出true
$a || $b //或 $a或$b为true时，输出true
$a OR $b //或 $a或$b为true时，输出true
!$a //非 $a不为true时，输出true
NOT $a //非 $a不为true时，输出true
$a XOR $b //异或 只有$a或$b为true时，输出true

相等操作符：

$a == $b; //是否相等，如果$a和$b相等，输出true
$a != $b; //是否不相等，如果$a和$b不相等，输出true
$a === $b; //是否相同，如果$a和$b相等，且类型相同，输出true

==与===的区别

$a = 520;//整数
$b = "520";//字符串
echo $a == $b;//为true，输出1
echo $a === $b;//因为类型不相同为false，所以不输出

比较操作符：

$a > $b; //大于 如果$a大于$b，输出true
$a < $b; //小于 如果$a小于$b，输出true
$a >= $b; //大于等于 如果$a大于等于$b，输出true
$a <= $b; //小于等于 如果$a小于等于$b，输出true
($a == $b) ? 2 : 3; //三元运算 如果$a和$b相等输出2，否则输出3

位操作符：

 　　进制转换

二进制 1 1 0 0 1 0 1 0 1
  256 128 64 32 16 8 4 2 1
十进制 256 128 0 0 16 0 4 0 1
（二进制）110010101=256+128+0+0+16+0+4+0+1=405（十进制）
二进制 110 010 101
  6 2 5
（二进制）110010101=625（八进制）
二进制 1 1001 0101
  1 9 5
（二进制）110010101=195（十六进制）
十进制 405 202 101 50 25 12 6 3 1
二进制倒叙 1 0 1 0 1 0 0 1 1
（十进制）405=110010101（二进制）

 

 

 
 
 
 
 
 
 
 
 
 
 
 
 
正数的原码，反码，补码都一样
2的原码：00000000 00000000 00000000 00000010
2的反码：00000000 00000000 00000000 00000010
2的补码：00000000 00000000 00000000 00000010
（符号位：左边第一个数，0位正数，1为负数）
负数的反码是原码符号位不变，其他位取反
负数的补码是反码加1
3的原码：10000000 00000000 00000000 00000011
3的反码：11111111 11111111 11111111 11111100
3的补码：11111111 11111111 11111111 11111101
$a & $b; //两位全为1则为1
$a | $b; //一个为1则为1
$a ^ $b; //一个为1，一个为0，则为1
~$a; //0变1,1变0
$a << $b; //左移 符号位不变，低位补0
$a >> $b; //右移 低位溢出，符号位不变，并用符号位补溢出的高位
2 & 3
要计算2&3的值，那必须把2和3的补码计算出来
由于正数的原码，反码,补码是一样的，所以
2 = 00000000 00000000 00000000 00000010
3 = 00000000 00000000 00000000 00000011
 两位全为1，则为1的要点，得
 00000000 00000000 00000000 00000010
然后将补码转换为反码，反码在转换为原码（由于第一位为0，所以为正数，正数的原码，反码，补码都是一样）
 00000000 00000000 00000000 00000010
所以最终结果为：
2 & 3 == 2
 
2 << 3
同样计算出2的补码
2 = 00000000 00000000 00000000 00000010
算数左移，符号位不变，低位补0，得
00000000 00000000 00000000 00010000
所以最终结果为：
2 << 3 == 16

字符串插入

  • 双引号，转义序列

 用双引号将字符串括起来，变量和转义序列都会解析

<?php
    $xiu = "kang";//$xiu为变量，\n为转义序列代表 换行符
    echo "$xiu \n hello";
?>

这个输出出现在浏览器源代码中，如果数据输出到文本文件中，也会被分成两行

  • 单引号

 用单引号将字符串括起来，变量和转义序列都不会被解析

<?php
    $xiu = "kang";
    echo '$xiu \n hello';//输出为：$xiu \n hello 
?>

但反斜杠放最后 \' 会被转义，导致语句报错，解决办法：写双反斜杠

<?php
    echo 'hello word\\';//输出为：hello word\
?>
  • 大括号

 在echo()或print()在输出字符串中嵌套复杂数据类型（数组/对象）时，解析时往往有点困难，解决办法：用大括号把变量括起来

<?php
    $array[0] = "修抗"; 
    echo "字符串 {$array[0]} 字符串";
?>
  • heredoc

 heredoc语法为输出大量文本提供一种便利的方法

它不使用单引号或双引号来界定字符串

<?php
    $val = "hello";
    echo <<<XIU
        $val "word" 'kang';
XIU;
?>

开始和结束标识符必须相同，可以自定义

标识符只能由字母数字下划线组成，数字和下划线不能开头

变量和转义序列会被解析，只有单引号或双引号不会被解析

开始标识符前面必须有三个左尖括号 <<<

结束标识符必须在一行的开始处

标识符前面或后面不能有空格或其他任何多余的字符

  • Nowdoc

 nowdoc操作等同于heredoc语法，区别：开始标识符必须用单引号括起来，不会解析变量和转义序列

作用：在浏览器中显示代码

<?php
    $val = "hello";
    echo <<<'XIU'
    $val "word" \n 'kang';
XIU;
?>

控制结构

  • 条件语句

 if语句

<?php
    if(true){//当条件为true时输出 "执行"
        echo "执行";
    }
?>

else语句

<?php
    if(false){//当条件为false时输出 "执行"
        echo "不执行";
    }else {
        echo "执行";
    }
?>

elseif语句

<?php
    if(false){//如果条件为true，就不执行下面的语句，条件为false就执行下一条语句else if()
        echo "if语句为true时执行";
    }else if(false){//如果条件为true，就不执行下面的语句，条件为false就执行下一条语句else
        echo "else if()语句为true时执行";
    }else {//当上面的条件都不满足时，执行else语句
        echo "不满足条件时执行";
    }
?>

switch语句

可以将switch语句看成else if()语句的变体

如果某个变量要和大量的值进行比较就可以使用switch()语句

<?php
    $xiu = 5;
    switch($xiu){
    case "$xiu<5":
        echo "当$xiu小于5时执行";
        break;//如果没有break，不管对错，会一直执行后面的case块
    case "$xiu>5":
        echo "当$xiu大于5时执行";
        break;
    default:
        echo "当$xiu等于5时执行";
    }
?>
  • 循环语句

while语句，输出1-10

<?php
    $xiu = 1;
    while($xiu <= 10){
        echo "$xiu <br/>";
        $xiu++;
    }
?>

 do...while语句

不管条件对错，至少执行一次循环

<?php
    $xiu = 1;
    do{
        echo "$xiu <br/>";
        $xiu++;
    }while($xiu < 1)//错误条件
?>

 for语句，输出1-10

第一种写法

<?php
    for($xiu=1;$xiu<=10;$xiu++){
        echo "$xiu <br/>";
    }
?>

第二种写法

<?php
    for($xiu=1;;$xiu++){
        if($xiu > 10){
            break;
        }
        echo "$xiu <br/>";
    }
?>

第三种写法

<?php
    $xiu=1;
    for(;;){
        if($xiu > 10){
            break;
        }
        echo "$xiu <br/>";
        $xiu++;
    }
?>

foreach语句

foreach最擅长处理循环数组

将超链接添加超链接

<?php
    $xiu = array("http://www.baidu.com","http://www.taobao.com","http://www.jd.com");
    foreach($xiu as $kang){
        echo "<a href=$kang>$kang</a><br/>";
    }
    /*
    输出结果为：
    http://www.baidu.com
    http://www.taobao.com
    http://www.jd.com
     */
?>

 处理键值对的数组：

将百度，淘宝，京东添加超链接

<?php
    $xiu = array(
    "百度"=>"http://www.baidu.com",
    "淘宝"=>"http://www.taobao.com",
    "京东"=>"http://www.jd.com"
    );
    foreach($xiu as $x=>$y){
        echo "<a href=$y>$x</a><br/>";
    }
    /*
    百度
    淘宝
    京东
     */
?>

break语句和goto语句

break会立即结束do...while,for,foreach,switch或while循环的执行

<?php
    //输出1-10
    for($xiu=1;$xiu<=10;$xiu++){
        if($xiu==6) {
            break;//当$xiu==6时结束循环
        }else {
            echo "$xiu <br/>";
        }
    }
?>

goto语句可以直接跳到一个循环或条件构造之外的某个特定位置

<?php
    //输出1-10
    for($xiu=1;$xiu<=10;$xiu++){
        if($xiu==6) {
            goto less;//当$xiu==6时结束循环，执行less语句
        }else {
            echo "$xiu <br/>";
        }
    }
    less: echo "跳出循环执行less语句";
?>

continue语句

continue使当前循环迭代结束，继续下次迭代

<?php
    //输出1-10
    for($xiu=1;$xiu<=10;$xiu++){
        if($xiu==6) {
            continue;//当$xiu==6时跳过本次循环，执行下一次循环
        }else {
            echo "$xiu <br/>";
        }
    }
?>
  • 文件包含语句

include()

include()语句将在其被调用的位置判断并包含一个文件

包含一个文件与赋复制该文件的数据到该语句所在的位置具有相同的结果

<?php
    include "index.php";//调用index.php文件,也可以引用引用远程文件
?>

确保只包含一个文件

include_once()函数作用与include()相同，不过它会先验证是否包含该文件，如果以包含该文件，include_once()将不在执行

<?php
    include "index.php";//执行
    include "index.php";//执行
    include_once "index.php";//不执行，因为上面已经包含了index.php文件
?>

请求文件

require()函数跟include()函数差不多

<?php
    require "index.php";//调用index.php文件
?>

require与include的区别：

include有返回值，require没有返回值

每次执行include都会读取文件，require只会读取一次文件

include报错时程序会继续执行下去，require报错时会终止程序运行

确保只请求一次文件

<?php
    require_once "index.php";//执行，确保调用文件只执行一次
?>

 加密（start）

PHP密码加密

为了避免服务器收到攻击，数据库泄露时，用户的明文密码不被泄露，一般会对密码进行单行不可逆加密：哈希

  • MD5

32位密文（固定不变）

<?php
    $xiu = "123456";
    echo md5($xiu);//输出：e10adc3949ba59abbe56e057f20f883e
?>
  • sha1

40位密文（固定不变）

<?php
    $xiu = "123456";
    echo sha1($xiu);//输出：7c4a8d09ca3762af61e59520943dc26494f8941b
?>
  • hash

64位与128位密文（固定不变）

<?php
    $xiu = "123456";
    //64位密文
    echo hash("sha256",$xiu);//输出：8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92
    //128位密文
    echo hash("sha512",$xiu);//ba3253876aed6bc22d4a6ff53d8406c6ad864195ed144ab5c87621b6c233b548baeae6956df346ec8c17f5ea10f35ee3cbc514797ed7ddd3145464e2a0bab413
?>
  • password_hash

60位~255位密文，跟PHP版本有关（值会变）

运行慢，也就意味着相同时间内，密码重试次数少，泄露风险低

<?php
    $xiu = "123456";
    echo password_hash($xiu,PASSWORD_DEFAULT);
?>
  • password_verify

因为password_hash每次运行结果都不一样，所以需要password_verify函数验证

<?php
    $xiu = "123456";
    $kang = password_hash($xiu,PASSWORD_DEFAULT);
    var_dump (password_verify($xiu,$kang));//bool(true)
?>

 加密（end）

正则表达式与字符串（start）

正则表达式

在PHP中有两套正则表达式函数库。

PCRE库（Perl Compatible Regular Expression），基于传统型NFA。PCRE库使用和Perl相同的语法规则实现了正则表达式的模式匹配

POSIX扩展库（Portable Operation System interface），基于POSIX NFA。POSIX扩展的正则表达式由POSIX 1003.2定义

一般而言，实现相同的功能，使用PCRE库的效率略占优势

  • 中括号

[0-9]匹配任何从0到9的十进制数

[a-z]匹配任何小写从a到z的字符

[A-Z]匹配任何大小从A到Z的字符

[A-Za-z]匹配任何大写A到小写z的字符

$name = "256";
if(preg_match("([2-9])",$name)){//匹配包含2到9的字符串
    echo "true";
}
  • 量词

p+。匹配任何至少包含一个字符p的字符串

p*。匹配任何包含零个或多个字符p的字符串

p?。匹配任何包含零个或一个字符p的字符串

p{2}。匹配任何包含两个连续p的字符串

p{2,3}。匹配任何包含两个或三个连续p的字符串

p{2,}。匹配任何包含两个或以上p的字符串

p$。匹配任何以p结尾的字符串

^p。匹配任何以p开头的字符串

[^0-9]。匹配任何不包含0到9的十进制数

p.p。匹配任何包含p和p之间的字符串

^.{2}$。匹配任何只包含两个字符的字符串

<b>(.*)</b>。匹配任何被<b></b>包围的字符串

p(hp)*。匹配任何包含一个p，p后面是hp的字符串

$name = "pass";
if(preg_match("/p+/",$name)){//匹配至少包含一个p的字符串
    echo "true";
}
  • 预定义字符范围（字符类）

[:digit:]数字[0~9]

[:lower:]小写字母[a~z]

[:upper:]大写字母[A~Z]

[:alpha:]大小写字母[A~Za~z]

[:alnum:]大小写字母以及数字[A~Za~z0~9]

[:xdigit:]十六进制字符[A~Fa~f0~9]

[:graph:]33~126范围的可打印ASCII字符

[:cntrl:]控制字符，如制表符、退格符或反斜杠

[:space:]空白字符：空格、水平制表符、垂直制表符、换行、换页或换行

[:punct:]标点符号

$name = "1314";
if(preg_match("([[:digit:]])",$name)){//匹配数字
    echo "true";
}
  • 修饰符

i不区分大小写

g查找所有出现

m将字符串视为多行

s将字符串视为一行

x忽略正则表达式中的空格和注释

$name = "xiukang";
if(preg_match("/XIU/i",$name)){//添加i不区分大小写
    echo "true";
}
  • 元字符

\A 只匹配字符串开头

\b 匹配单词边界

\B 匹配除单词边界之外的任何字符

\d 匹配数字字符

\D 匹配非数字字符

\s 匹配空白字符

\S 匹配非空白字符

[] 包围一个字符类

() 包围一个字符分组或定义一个反引用

$ 匹配行尾

^ 匹配行首

. 匹配除换行之外的任何字符

\ 引出下一个元字符

\w 匹配任何只包含数字字母和下划线的字符串

\W 忽略下划线、数字和字母

$name = "xiukang";
if(preg_match("/g\$/",$name)){//匹配以g结尾的字符串
    echo "true";
}
  • PHP的正则表达式函数

 ·搜索模式

preg_match()函数

//如果匹配的字符串全部为小写字母则返回false
$name = "xiukang";
if(preg_match("([^[:lower:]])",$name)){
    echo "true";
}else {
    echo "false";
}

preg_match()函数的第三个参数的作用，将字符串划分成二维数组

$xiu = '/(www)(.)(baidu)(.)(com)/';
$kang = 'www.baidu.com';
preg_match_all($xiu,$kang,$match);
echo $match[0][0];//www.baidu.com
echo $match[1][0];//www
echo $match[2][0];//.
echo $match[3][0];//baidu
echo $match[4][0];//.
echo $match[5][0];//com

·搜索数组

preg_grep()函数

$xiu = '/[0-9]/';//匹配包含1到9的字符串
$kang = array('123','456','abc','13ab','789');
$arr = preg_grep($xiu,$kang);
print_r($arr);//Array ( [0] => 123 [1] => 456 [3] => 13ab [4] => 789 )

preg_grep()函数的第三个参数

$xiu = '/[0-9]/';//匹配包含1到9的字符串
$kang = array('123','456','abc','ab','789');
$arr = preg_grep($xiu,$kang,true);//true表示返回正则表达式未匹配的元素
print_r($arr);//Array ( [2] => abc [3] => ab )

·替换匹配模式的所有字符串

preg_replace()函数

$name = "xiukang 1997";
//将匹配的字符串替换为2018
$kang= preg_replace("([0-9]+)","2018", $name);
print $kang;//xiukang 2018

·匹配所有出现的模式

preg_match_all()函数

（。。。）

·界定特殊的正则表达式字符

preg_quote()函数

在特殊含义的字符前插入一个反斜杠

特殊字符：$ ^ * () + = {} [] | \\ : <>

$name = "$500";
echo preg_quote($name);//返回"\$500"
echo $name;//返回"$500"

·创建定制的替换函数

preg_relpace_callback()函数

// 将文本中的年份增加一年
$name = "xiu kang 2018";
function setName($sear){
  //通常: $sear[0]是完成的匹配，$sear[1]是第一个捕获子组的匹配，以此类推
  return $sear[1].($sear[2]+1);
}
echo preg_replace_callback("|(\D)(\d{4})|","setName",$name);//输出"xiu kang 2019 "

·以不区分大小写的方式将字符串划分为不同元素

preg_split()函数

$xiu = "xiu++kang+++++sear";
$kang = preg_split("/\++/",$xiu);
foreach($kang as $sear){
    echo "$sear<br/>";//输出"xiu kang sear"
}

其他的字符串函数

  • 确定字符串长度

 strlen()函数

$pass = "2435325";
if(strlen($pass)>10){
    echo "成功";
}else {
    echo "密码长度必须大于十位数";
}
  • 比较两个字符串

·不区分大小写比较两个字符串

strcasecmp()函数

strcasecmp()函数将两个字符串转换为二进制，然后相减（不区分大小写）

$email1 = "admin@xiu.com";
$email2 = "ADMIN@xiu.com";
echo strcasecmp($email1,$email2);//返回0

·区分大小写比较两个字符串

strcmp()函数

strcmp()函数将两个字符串转换为二进制,然后比较大小

$text1 = $text2 返回0

$text1 < $text2 返回-1

$text1 > $text2 返回1

$text1 = "修";
$text2 = "抗";
echo strcmp($text1,$text2);//返回-1
  • 处理字符串大小写

非字母字符不受影响

 ·将字符串全部转换为小写

strtolower()函数

$text = "XIU";
echo strtolower($text);//返回"xiu"

·将字符串全部转换为大写

strtoupper()函数

$text = "xiu";
echo strtoupper($text);//返回"XIU"

·将字符串的首字母转换为大写

ucfirst()函数

$text = "xiu";
echo ucfirst($text);//返回"Xiu"

·将字符串的每个单词的首字母转换为大写

ucwords()函数

$text = "xiu kang";
echo ucwords($text);//返回"Xiu Kang"

 

正则表达式函数的代替函数

·根据预定义的字符对字符串进行语法分析

strtok()函数

$name = "www.baidu/com";
$tokens = "./";//设置两个定界符（. /）
$tokName = strtok($name,$tokens);
while($tokName){
    echo "$tokName<br/>";//输出"www baidu com"
    $tokName = strtok($tokens);//在后期调用时，不在包含第一个参数
}

·获取字符串最后出现的位置

strrpos()函数

echo strrpos("H e l l o w","l");//返回6

·获取字符串的一部分

strstr()函数

$name = "xiukang@qq.com";
echo strstr($name,"@");//@qq.com

·替换字符串

str_replace()函数

str_ireplace()函数（不区分大小写）

$name = "xiukang@qq.com";
echo str_replace("@","*",$name);//xiukang*qq.com

·获取字符串中的指定字符

subste()函数

$name = "Hellow";
echo substr($name,1,-2);//ell

·获取字符串中指定字符出现的次数

$name = "Hellow";
echo substr_count($name,"l");//返回2

·将数组转换为字符串

implode()函数

$arr = array("xiu","kang","sear");
echo implode("|",$arr);//输出"xiu|kang|sear"
  • 填充和替换字符串

·删除字符串开始的字符

ltrim()函数

echo ltrim("Hellow","H");//ellow

·删除字符串末尾的字符

rtrim()函数

echo rtrim("Hellow","w");//Hello

·删除字符串两端的字符

trim()函数

echo trim("Hellow","wH");//ello

填充字符串

str_pad()函数

echo str_pad("xiu",5,"*")."kang";//输出"xiu**kang"

正则表达式与字符串（end）

处理文件和操作系统（start）

了解文件和目录

  • 解析目录路径

·获取路径的文件名

basename()函数返回路径的文件名部分

$url = "D:\Apache24\htdocs\index.html";
echo basename($url);//index.html
echo basename($url,".html");//index

·获取路径的目录

dirname()函数返回路径的目录

$url = "D:\Apache24\htdocs\index.html";
echo dirname($url);//D:\Apache24\htdocs

·了解更多关于路径的信息

pathinfo()函数创建一个关联数组，其中包括路径的目录名，基本名和扩展名

$url = "D:\Apache24\htdocs\index.html";
print_r(pathinfo($url));//Array ( [dirname] => D:\Apache24\htdocs [basename] => index.html [extension] => html [filename] => index )

·确定绝对路径

realpath()函数返回文件名的绝对路径

$url = "1.png";//1.png跟测试html在同级目录
echo realpath($url);//D:\Apache24\htdocs\1.png
  • 计算文件，目录和磁盘大小

·确定文件大小

filesize()函数返回指定文件的大小

$url = "1.png";//1.png跟测试html在同级目录
echo filesize($url);//1420168字节

·计算磁盘的可用空间

disk_free_space()函数返回指定目录所在盘的可用空间

$url = "htdocs";//htdocs是html的目录
echo disk_free_space($url);//102040064000字节

·计算磁盘的总容量

disk_total_space()函数返回指定目录所在盘的总空间

$url = "htdocs";//htdocs是html的目录
echo disk_total_space($url);//107582844928字节

·获取目录大小

（。。。）

  • 确定访问和修改时间

获取文件最后访问的时间

fileatime()函数获取文件最后访问的时间

$url = "text.txt";//text.txt"跟测试html在同级目录
echo date("y-m-d g:i:sa",fileatime($url));

确定文件最后改变的时间

filectime()函数返回文件最后修改的时间

$url = "text.txt";//text.txt"跟测试html在同级目录
echo date("y-m-d g:i:sa",filectime($url));

处理文件

  • 识别文件末尾字符

fgets()函数确定是否达到资源末尾

//打开只读文件
$xiu = fopen("text.txt","r");//text.txt"跟测试html在同级目录
//feof()函数确定是否达到资源末尾
while(!feof($xiu)){
    //fgets()函数读取文件内容
    echo fgets($xiu);
}
//fclose()函数关闭资源
fclose($xiu);
  • 打开和关闭文件

·打开文件

R只读。文件指针置于文件开头

r+读写。文件指针置于文件开头

W只写。在写入之前删除文件内容，将指针置于文件开头，如果文件不存在则创建

w+读写。在读写或写入之前删除文件内容，将指针置于文件开头，如果文件不存在则创建

A只写。文件指针置于文件末尾，如果文件不存在则创建

a+读写。文件指针置于文件末尾，如果文件不存在则创建

x创建并打开只读文件，如果文件存在，fopen()返回失败

x+创建并打开读写文件，如果文件存在，fopen()返回失败

fopen()函数

fopen("text.txt","x");//创建并打开只读文件text.txt

·关闭文件

fclose()函数关闭文件

$xiu = fopen("text.txt","x");//创建并打开只读文件text.txt
fclose($xiu);//关闭文件
  • 将字符串写入文件
$text = "xiukang修抗";//写入文件的内容
$xiu = fopen("text.txt","a+");//创建并打开只读文件text.txt
fwrite($xiu,$text);//将字符串写入文件
fclose($xiu);//关闭文件
  • 读取文件

·将文件读入数组

file()函数

$xiu = file("text.txt");//file()函数将文件读入数组
foreach($xiu as $kang){
    list($name,$age) = explode(" ",$kang);
    echo $name;
    echo $age;
}

·将文件内容读入字符串变量

file_get_contents()函数

$xiu = file_get_contents("text.txt");//file_get_contents()函数将文件读入字符串
$kang = explode("\n",$xiu);//将字符串每一行放入数组
foreach($kang as $sear){
    list($name,$age) = explode(" ",$sear);
    echo $name;
    echo $age;
}

·读取指定数目的字符

fgets()函数

$xiu = fopen("text.txt","a+");
while(!feof($xiu)){//feof()函数输出文本的所有行，直到文本结束（EOF）
    echo fgets($xiu,1024);//fgets()函数默认读取一行1024字符，遇到换行符和EOF都会停止执行
}
fclose($xiu);

·从输入中剔除标签

fgetss()函数

$xiu = fopen("text.html","r+");//text.html里面的内容为<h1>This is a paragraph.</h1>
echo fgetss($xiu,1024,"<h1>,<h2>");//fgetss()函数会剔除指定的标签
fclose($xiu);

·以一次读取一个字符的方式读取文件

fgetc()函数

$xiu = fopen("text.txt","r+");//文件内容为Hellow
echo fgetc($xiu);//fgetc()函数获取文件中的一个字符
fclose($xiu);

·忽略换行符

 fread()函数

$xiu = fopen("text.txt","r");
$kang = filesize("text.txt");//filesize()函数获取该文件的字数
echo fread($xiu,$kang);//fread()函数读取文件时忽略换行符
fclose($xiu);

·读取整个文件

  readfile()函数

readfile("text.txt");//readfile()函数将整个文件输出到浏览器中

·根据预定义的格式读取文件

 fscanf()函数

/*
2424-2423-5235
4633-6547-3523
4536-6346-3634
 */
$xiu = fopen("text.txt","r+");
while($user = fscanf($xiu,"%d-%d-%d")){//fscanf()函数按指定方式解析文件
    list($par1,$par2,$par3) = $user;
    printf("par1：%d，par2：%d，par3：%d",$par1,$par2,$par3);
}
  • 移动文件指针

fseek()函数

ftell()函数

rewind()函数

$xiu = fopen("text.txt","r+");
fseek($xiu,"20");//fseek()函数将文件指针偏移20字符
echo ftell($xiu);//ftell()函数获取指针位置
rewind($xiu);//rewind()函数将文件指针移到文件开始处
fclose($xiu);
  • 读取目录内容

 打开目录

opendir()函数

opendir("../htdocs");//opendir()函数打开目录句柄，跟fopen()差不多

关闭目录

closedir()函数

$xiu = opendir("../htdocs");
closedir($xiu);//关闭目录流

解析目录内容

readdir()函数

$xiu = opendir("../htdocs");
while($kang = readdir($xiu)){//readdir()函数获取该目录下所有文件名
    echo "$kang<br/>";
}
closedir($xiu);

将目录读入数组

scandir()函数

print_r(scandir("../htdocs"));//scadir()函数将目录返回数组

执行shell命令

·删除目录

rmdir()函数

rmdir("../text");//删除text目录，该目录必须为空

·重命名

rename()函数

rename("text.txt","txt.txt");//将text文件名修改为txt名

·指定文件的访问和修改时间

touch()函数

touch("text.txt");//touch()函数的第二个参数设置访问时间，第三个是修改时间，默认当前时间

系统级程序执行

  • 清理输入

 界定输入

escapeshellarg()函数

$str = "文本";
echo escapeshellarg($str);//将字符串添加一个双引号

转义可能危险的输入

escapeshellcmd()函数

$str = " # $ ; , | * ? , ~ < > ( ) { } [ ] & \\ \x0A \xFF";
escapeshellcmd($str);escapeshellcmd()函数自动转义以上字符

处理文件和操作系统（end）

时间和日期（start）

PHP的日期和时间库

  • 验证日期

checkbox()函数

echo checkdate(4,5,2018);//checkdate()函数判断日期是否合法，正确返回true
  • 格式化日期和时间

Y年 m月 d日 H时 i分 s秒

date()函数

echo date("Y:m:d");//输出年月日2018:04:14
  • 将时间戳转换用户友好的值

getdate()函数

print_r(getdate());//getdate()函数获取当前的时间戳数组
  • 处理时间戳

确定当前的时间戳

time()函数

echo time();//获取当前的时间戳1523712349

将时间戳转换为可读时间

date()函数

echo date("H:i:s",1523712349);//21:25:49

指定日期和时间创建时间戳

mktime()函数

echo mktime(12,30,00,2,28,2018);//mktime()函数返回指定时间的时间戳，默认当前时间1519792200

两个日期差

$tim1 = time();//当前时间戳
$tim2 = mktime(0,0,0,8,9,1997);//指定时间戳
echo  ($tim1 - $tim2);//相差652657442秒

日期函数

  • 显示网页的最新修改日期
echo getlastmod();//获取当前网页最后修改的时间戳
  • 确定当前月份的天数

 date()函数

echo date("t");//获取当前月的总天数
  • 确定任意给定月份的天数

date()函数

$time = mktime(0,0,0,8,9,1997);
echo date("t",$time);//指定月的天数
  • 计算当前日期后X天的日期

strotime()函数

$time = strtotime("+10 days");//strtotime()函数计算十天后的日期
echo date("Y-m-d",$time);
  • DataTime构造函数简介

DateTime()函数

$date = new DateTime();//创建一个日期对象，时间为当前时间              
  • 格式化日期

format()方法

$date = new DateTime();
echo $date -> format("Y-m-d H:i:s");//2018-04-15 19:37:18
  • 实例化后设置日期

setDate()方法

$date = new DateTime();
$date -> setDate(2018,5,20);//setDate()方法设置日期
echo $date -> format("Y-m-d");//format()方法输出时间2018-05-20
  • 实例化后设置时间

setDate()方法

$date = new DateTime();
$date -> setTime(21,35);
echo $date -> format("H:i:s");//21:35:00
  • 修改日期和时间

modify()方法

$date = new DateTime();//19:33:44 
$date -> modify("5 hours");//modify()方法将添加5个小时
echo $date -> format("H:i:s");//00:33:44
  • 计算两个日期之差

diff()方法

$date1 = new DateTime();//2018-4-15
$date2 = new DateTime("2018-4-20");
$sumdate = $date1 -> diff($date2);//diff()方法计算时间差
echo $sumdate -> format("%d");//4

时间和日期（end）

数组（start）

什么是数组

 传统上把数组（array）定义为一组某种共同特性的元素，这里的共同特性包括相似性和类型等，每个元素由特殊的标识符来区分，这称为键（key）

PHP的数组的元素可以不为同一种类型

创建数组

PHP提供了正式和非正式的数组声明方法

  • 非正式的数组声明方法
<?php
    //创建数组
    $xiu[0] = "xiu";
    $xiu[1] = "kang";
    $xiu[2] = "ai";
    //...
    $xiu[99] = "wo";
    //显示数组$xiu第二个元素
    echo $xiu[1];//输出 "kang"
?>

如果索引值是数值，而且还是递增的，就可以在创建时省略索引值

<?php
    //创建数组
    $xiu[] = "xiu";
    $xiu[] = "kang";
    $xiu[] = "ai";
    $xiu[] = "wo";
    //显示数组$xiu第二个元素
    echo $xiu[1];//输出 "kang"
?>

创建关联数组

<?php
    //创建关联数组
    $xiu["sichuan"] = "deyang";
    $xiu["sichuan"] = "chengdu";
    $xiu["shanghai"] = "jinshan";
    $xiu["shanghai"] = "baoshan";
?>
  • 用array()创建数组（正式）

 array()函数接受0个或多个元素作为输入，返回一个包含这些输入元素的数组

<?php
    $xiu = array("xiu","kang","ai","wo");
?>

使用array()创建关联数组

<?php
    $xiu = array(
    "sichuan"=>"deyang",
    "sichuan"=>"chengdu",
    "shanghai"=>"jinshan",
    "shanghai"=>"baoshan"
    );
?>
  • 用list()提取数组

 list()与 array()类似，只是它可以在一次操作中从数组提取多个值，同时为多个变量赋值

<?php
    /*
    打开text.txt文件
    文件每一行包括用户名，密码和喜欢的颜色，每一项用竖线分隔
    其中一行为 xiu|123|red
    */
    $users = fopen("text.txt","r");
    //若未达到EOF，则获取下一行（EOF=资料源无更多的资料可读取）
    while($line = fgets($users,4096)){
        //用explode()分离数据判断
        list($user,$pass,$color) = explode("|",$line);
        //格式化数据并输出
        printf("user: %s ",$user);
        printf("pass：%s ",$pass);
        printf("color：%s <br/>",$color);
    }
    //关闭流
    fclose($users);
?>

注：list()依靠函数explode()（它返回一个数组）将每一行分解为三个元素这里explode()用竖线作为元素的分隔符，然后这些元素分别赋给$user,$pass,$color

  • 用预定义的值范围填充数组
<?php
    $xiu = range(0,20,3);//创建0-20的数组，间隔为3
    //$xiu = array(0,3,6,9,12,15,18);
?>

也可以创建字母数组

<?php
    $xiu = range("A","E");//创建A到E的数组
    //$xiu = array("A","B","C","D","E");
?>
  • 测试数组

 is_array()判断某个变量是否为数组

<?php
    $xiu = array();
    echo is_array($xiu);//输出结果为1 (true)
?>

输出数组

用foreach()输出数组

<?php
    $xiu = array("xiu","kang","sear");
    foreach($xiu as $kang){
        echo "$kang<br/>";
    }
    // 输出结果为xiu kang sear
?>

打印数组用以测试

<?php
    $xiu = array("xiu","kang","sear");
    print_r($xiu); //输出结果为：Array ( [0] => xiu [1] => kang [2] => sear ) 
?>

 

输出多维数组（数组的数组）

（。。。）

添加或删除数组元素

  • 在数组头添加元素

 array_unshift()函数在数组头添加元素，所有的数值键都会修改，关联键不受影响

<?php
    $xiu = array("xiu","kang");
    array_unshift($xiu,"wo","ai");
    //xiu = array("wo","ai","xiu","kang");
?>
  • 在数组尾添加元素

 array_push()函数在数组尾添加元素，添加新值后返回数组的元素的总数

<?php
    $xiu = array("xiu","kang");
    array_push($xiu,"ai","wo");
    //xiu = array("xiu","kang","ai","wo");
?>
  • 在数组头删除元素

 array_shift()函数删除并返回数组中的第一个元素，如果使用的数值键，则所有相对应的键都会下移，关联键不受影响

<?php
    $xiu = array("xiu","kang");
    array_shift($xiu);
    //$xiu = array("kang");
?>
  • 在数组尾删除元素

 array_pop()函数删除并返回数组中最后一个元素

<?php
    $xiu = array("xiu","kang");
    array_pop($xiu);
    //$xiu = array("xiu");
?>

定位数组元素

  • 搜索数组

 in_array()函数在数组中搜索特定的值，如果有这个值则返回true，否则返回false

<?php
    $xiu = array("xiu","kang");
    //判断$xiu数组中是否有"kang"这个元素
    echo in_array("kang",$xiu,"string");//返回1 第三个参数为可选，强制in_array()在搜索时考虑类型
?>

搜索关联数组键

array_key_exists()函数搜索关联数组中指定的键，如果有这个键则返回true，否则返回false

<?php
    $xiu = array("xiu"=>"修","kang"=>"抗","zhong"=>"中");
    array_key_exists("kang",$xiu);
?>

搜索关联数组值

array_search()函数搜索关联数组中指定的值，如果有这个值则返回相对应的键，否则返回false

<?php
    $xiu = array("xiu"=>"修","kang"=>"抗","zhong"=>"中");
    echo array_search("抗",$xiu);
?>
  • 获取数组键
<?php
    $xiu = array("xiu"=>"修","kang"=>"抗","zhong"=>"中");
    array_keys($xiu);//获取$xiu数组中所有的键
    array_keys($xiu,"抗");//获取$xiu数组中值为"抗"的键
?>
  • 获取数组值
<?php
    $xiu = array("xiu"=>"修","kang"=>"抗","zhong"=>"中");
    array_values($xiu);//获取$xiu数组中所有的值，并自动获取对应的键
?>

遍历数组

  • 获取当前数组键

key()函数返回当前指针所在位置的键 

<?php
    $xiu = array("xiu"=>"修","kang"=>"抗","zhong"=>"中");
    while($key = key($xiu)){
        echo "$key<br/>";
        next($xiu);//将指针移到下一个元素
    }
?>
  • 获取当前数组值

 current()函数返回数组中当前指针所在位置的数组值

<?php
    $xiu = array("xiu"=>"修","kang"=>"抗","zhong"=>"中");
    while($key = current($xiu)){
        echo "$key<br/>";
        next($xiu);//将指针移到下一个元素
    }
?>
  • 移动数组指针

 next()函数返回当前指针下一个位置的数组值（数组默认指针为第一个元素）

<?php
     $xiu = array("xiu","kang","sear");
     echo next($xiu);//返回"kang"
     echo next($xiu);//返回"sear"
?>

prev()函数返回当前指针前一个位置的数组值，如果指针为第一个，则返回false

<?php
     $xiu = array("xiu","kang","sear");
     echo next($xiu);//返回"kang"
     echo prev($xiu);//返回"xiu"
?>

reset()函数将指针移到第一个数组位置

<?php
     $xiu = array("xiu","kang","sear");
     reset($xiu);
?>

end()函数将指针移到最后一个数组位置

<?php
     $xiu = array("xiu","kang","sear");
     end($xiu);
?>
  • 向函数传递数组值

 用户自定义函数必须有两个参数，一个表示数组值，一个表示数组键

<?php
    function xiu($val,$key){
        echo "$key**$val<br>";
    }
    $kang = array("1"=>"2","3"=>"4","5"=>"6");
    array_walk($kang,"xiu");
    /*
    1**2
    3**4
    5**6
     */
?>

确定数组的大小和唯一性

  • 确定数组的大小

 count()函数返回数组中值的总数

<?php
    $xiu = array("xiu","kang","sear");
    echo count($xiu);//因为有三个值，所以返回3
?>

sizeof()函数是count()的别名，他们的功能是一样的

  • 统计数组元素出现的频次

 array_count_values()函数返回一个关联数组，键表示值，值表示这个数组的值出现的次数

<?php
    $xiu = array("xiu","kang","kang");
    $kang = array_count_values($xiu);
    print_r($kang);//Array ( [xiu] => 1 [kang] => 2 ) 
?>
  • 确定唯一的数组元素

 array_unique()函数会删除数组中所有重复的值，并返回一个由唯一值组成的数组

<?php
    $xiu = array("xiu","kang","kang");
    $kang = array_unique($xiu);
    foreach($kang as $sear){
        echo "$sear<br/>"; //返回"xiu","kang"
    }
?>

数组排序

  • 逆置数组元素的顺序

 array_reverse()函数将数组中的元素的顺序倒叙

<?php
    $xiu = array("xiu","kang","sear");
    $kang = array_reverse($xiu,true);//将数组倒叙，true表示将键也倒叙，关联数组不受影响
?>
  • 置换数组的键和值

 array_flip()函数将数组中的键和值交换位置

<?php
    $xiu = array("xiu","kang","sear");
    $kang = array_flip($xiu);
    print_r($kang);//Array ( [xiu] => 0 [kang] => 1 [sear] => 2 ) 
?>
  • 数组排序

 sort()函数将数组的元素值进行升序（由低到高），键将会重新从0开始

rsort()函数将数组的元素值进行降序（从高到底），键将会重新从0开始

<?php
    $xiu = array("5","3","9");
    sort($xiu);//将数组由低到高排序
    print_r($xiu);//Array ( [0] => 3 [1] => 5 [2] => 9 ) 
?>

asort()函数与sort()函数相同，只是保存键值对关系

arsort()函数和rsort()函数相同，只是保存键值对关系

<?php
    $xiu = array("a"=>"5","b"=>"3","c"=>"9");
    asort($xiu);//将数组由低到高排序
    print_r($xiu);//Array ( [b] => 3 [a] => 5 [c] => 9 ) 
?>

natsort()函数提供了一种平常使用的排序机制，升序

natcasesort()函数与natsort()函数相同，只是不区分大小写

<?php
    $xiu = array("xiu3a","xiu1a","xiu2a");
    natsort($xiu);//将数组由低到高排序
    print_r($xiu);//Array ( [1] => xiu1a [2] => xiu2a [0] => xiu3a ) 
?>

ksort()函数按键的大小排序，升序

krsort()函数按键的大小排序，降序

<?php
    $xiu = array("b"=>"5","a"=>"3","c"=>"9");
    ksort($xiu);//将数组由低到高排序
    print_r($xiu);//Array Array ( [a] => 3 [b] => 5 [c] => 9 )  
?>

shuffle()函数将对数组随机排序

<?php
    $xiu = array("a","b","c");
    shuffle($xiu);//随机排序
    print_r($xiu);//Array ( [0] => c [1] => a [2] => b ) 每次结果不一样
?>

usort()函数自定义数组排序

（。。。）

合并，拆分，接合和分解数组

  • 合并数组

 array_merge()函数将两个或以上的数组进行合并，会忽略数组的键

<?php
    $xiu = array("a","b","c");
    $kang = array("7","8","9");
    $sear = array_merge($xiu,$kang);//合并数组
    print_r($sear);//Array ( [0] => a [1] => b [2] => c [3] => 7 [4] => 8 [5] => 9 ) 
?>
  • 递归追加数组

 array_merge_recursive()函数与array_merge()函数差不多

如果数组元素的键为数字则会忽略，会被重新赋值，而其他类型不会

<?php
    $xiu = array("a"=>"b","4"=>"d");
    $kang = array("e"=>"f","7"=>"h");
    $sear = array_merge_recursive($xiu,$kang);//合并数组
    print_r($sear);//Array ( [a] => b [0] => d [e] => f [1] => h ) 
?>
  • 合并两个数组

 array_combine()函数会生成一个新的数组

输入的两个数组大小必须相同，不能为空

第一个数组为键，第二个数组为值

<?php
    $xiu = array("a","b");
    $kang = array("c","d");
    $sear = array_combine($xiu,$kang);
    print_r($sear);//Array ( [a] => c [b] => d ) 
?>
  • 拆分数组

 array_slice()将返回数组中的一部分

<?php
    $xiu = array("a","b","c","d","e","f");
    $kang = array_slice($xiu,3);//拆分第三个元素之后的元素，如果是 -3 则拆分最后三个元素
    print_r($kang);//Array ( [0] => d [1] => e [2] => f ) 
?>

拆分第二个元素之后和最后两个元素之前的元素

<?php
    $xiu = array("a","b","c","d","e","f");
    $kang = array_slice($xiu,2,-2，true);//拆分第二个元素之后和最后两个元素之前的元素，true表示保持数组对应的键
    print_r($kang);//Array ( [0] => c [1] => d ) 
?>
  • 接合数组

 array_splice()函数删除选择的元素

<?php
    $xiu = array("a","b","c","d","e","f");
    $kang = array_splice($xiu,3);//删除数组中第三个元素之后的元素
    print_r($kang);//Array ( [0] => d [1] => e [2] => f ) 
?>

替换数组元素

<?php
    $xiu = array("a","b","c","d");
    $kang = array_splice($xiu,2,-1,array("x","y"));//删除数组第二个元素之后和最后一个元素之前的元素，并替换为"x","y"
    print_r($kang);//Array ( [0] => c ) 
    print_r($xiu);//Array ( [0] => a [1] => b [2] => x [3] => y [4] => d ) 
?>
  • 求数组的交集

 array_intersect()返回第一个数组中且其他数组中有的值（忽略键）

array_intersect_assoc()回第一个数组中且其他数组中有的键值对（键值必须一样）

<?php
    $xiu1 = array("a","b","c","d");
    $xiu2 = array("e","a","c","f");
    $xiu3 = array("c","g","h","a");
    $diff = array_intersect($xiu1,$xiu2,$xiu3);
    print_r($diff);//Array ( [1] => a [3] => c ) 
?>
  • 求数组的差集

 array_diff()返回第一个数组中且其他数组中没有的值（忽略键）

array_diff_assoc()回第一个数组中且其他数组中没有的键值对（键值必须一样）

<?php
    $xiu1 = array("a","b","c","d");
    $xiu2 = array("e","a","c","f");
    $xiu3 = array("c","g","h","a");
    $diff = array_diff($xiu1,$xiu2,$xiu3);
    print_r($diff);//Array ( [1] => b [3] => d ) 
?>

其他有用的数组函数

  • 返回一组随机的键

 array_ranf()函数返回一组随机的键

<?php
    $xiu = array("a"=>"b","c"=>"d","e"=>"f");
    $kang = array_rand($xiu,2);//返回2个随机的键
    print_r($kang);
?>
  • 对数组的的值进行求和

array_sum()函数返回数组值的合，会忽略字符串

<?php
    $xiu = array(3,"holle",4);
    echo array_sum($xiu);//返回7
?>
  •  划分数组

 array_chunk()函数将数组划分成多维数组

<?php
    $xiu = array("a","b","c","d","e","f");
    $kang = array_chunk($xiu,3);//每3个元素划分为一个多维数组里面的一个元素
    print_r($kang);//Array ( [0] => Array ( [0] => a [1] => b [2] => c ) [1] => Array ( [0] => d [1] => e [2] => f ) ) 
?>

数组（end）

函数（start） 

调用函数

标准的PHP发行包中有1000多个标准函数

假设函数库已经编译到安装发行包中或include()或require()语句包含了相应的函数库，就可以指定函数名调用函数

计算5的3次方，就可以调用PHP的pow()函数

<?php
    $value = pow(5,3);//pow()函数
    echo $value;//返回125
?>

也可以不把值赋给变量，而是直接输出

<?php
    echo pow(5,3);//返回125
?>

也可以进行拼接

echo "5的3次方为".pow(5,3);//输出为"5的3次方为125"

或者使用printf()

printf ("5的3次方为 %d",pow(5,3));//输出为"5的3次方为125"

创建函数

<?php
    function xiu(){
        echo "创建函数";
    }
?>

调用上面的函数

<?php
    xiu();//输出为"创建函数" 
?>
  • 按值传递参数
<?php
    //创建一个函数，确定销售税率，将税率加在价格上，计算出商品的总价
    function sear($xiu,$kang){
        $sum = $xiu + $xiu * $kang;
        printf ("该商品的价格为：%.2f",$sum);
    }
    sear(5,0.1);//商品价格为5，税率为0.1，最终结果为："该商品的价格为：5.50 "
?>

也可以传递变量，称为按值传递

$x = 5;
$y = 0.1;
sear($x,$y);
  • 按引用传递参数

 在函数内对参数所做的修该也可以体现在函数作用域外，就需要引用传递参数，要在参数前面加&符号

<?php
    $xiu = 6;
    $kang = 3;
    function xiu(&$xiu,$kang){
        $xiu++;//修改$xiu的变量
        $kang++;//修改$kang的变量
    }
    xiu($xiu,$kang);//执行函数
    echo $xiu;//$xiu值已经改变，输出为7
    echo $kang;//$kang值未改变，输出为3
?>
  • 默认参数值

 输入参数默认值，可以在没有提供其他值的情况下，就会把默认值自动赋给参数

<?php
    function xiu($xiu,$kang=5){//设置默认参数$kang=5;
        echo $xiu+=$kang;
    }
    //使用默认参数
    xiu(3);//输出为8
    //不使用默认参数
    xiu(4,6);//输出为10
?>

默认参数值必须位于参数列表末尾且为常数表达式，不能指定函数调用或变量等非常量值

也可以指定某个参数为可选参数，可选参数需要放到参数末尾，而且指定其默认值为空

<?php
    function xiu($xiu,$kang=""){//设置默认参数$kang=5;
        //必须将$kang设置为数字类型，不然会报错 "non-numeric value encountered" 
        settype($kang,"double");//将字符串类型设置为浮点型类型
        echo $xiu += $kang;
    }
    //使用默认参数
    xiu(3);//输出为3
    //不使用默认参数
    xiu(4,6);//输出为10
?>

如果指定了多个可选参数，可以选择性的传递某些参数

<?php
    function xiu($xiu1,$xiu2="",$xiu3=""){
        //同样将字符串类型设置为浮点型类型
        settype($xiu2,"double");
        settype($xiu3,"double");
        echo $xiu1 + $xiu2 +$xiu3;
    }
    xiu(3,"",4);//输出为7
?>
  • 使用类型提示

 可以强制将参数设置为某个类的对象或数组 Customer

function xiu (Customer $array){}
  • 从函数返回值

return()

return()语句可以向函数调用者返回任意确定的值，将程序控制权返回到调用者的作用域

如果return()语句在全局作用域时，会终止脚本的执行

<?php
    function xiu(){
        return 5+5;//返回10
    }
    echo xiu();//输出return()语句返回的值
?>

返回多个值

创建一个获取数据库中获取用户数据的函数，user，pass，name

利用list()构造从数组中获取值

<?php
    $array = array("user","pass","age");
    //执行list()构造,$user,$pass和$age分别被赋值user,pass和age
    list($user,$pass,$age) = $array;
    //输出list()构造的值
    printf("用户名:%s,密码：%s,年龄:%s",$user,$pass,$age);//输出 "用户名:user,密码：pass,年龄:age "
?>
  • 递归函数

递归函数就是调用函数本身

<?php
    function xiu($a=0){
        $a++;
        if ($a<10) {
              xiu($a);//调用函数本身
        }
        echo $a;
    }
    xiu();//输出10-1
?>

 （。。。）

函数库

在一个文件中简单的聚集函数定义就可以创建函数库了

<?php
    function xiu($red,$bule){
        //此处为函数体
    }
    function kang($xiu,$kang){
        //此处为函数体
    }
    function sear(){
        //此处为函数体
    }
?>

最好所使用一个能清楚的说明其用途的命名约定来命名

不要使用不合适的扩展名将这个文件保存到服务器文档，否则Web服务器会传递未解析的文件内容，佷可能导致用户从浏览器读取该文件并浏览代码

可以使用include(),require()将这个函数库插入到脚本

<?php
    include ("index.php");
?>

也可以使用php.ini的auto_prepend配置指令自动完成脚本的插入

 函数（end）

对象（start）

对象：

OOP的好处

  • 封装

封装可以隐藏实现细节，使代码模块化，代码重用

  • 继承

继承可以扩展已存在的代码模块（class），代码重用

  • 多态

为了类在继承和派生的时候，保证实例的某一属性正确调用，接口重用

关键的OOP概念

  • 类

 实体的性质和行为的具体定义称为类（class）

类用于表示要在应用程序中处理的实际事务

每个实体都包含一组性质和行为，在OOP中分别称为属性（property）和方法（method）

<?php
    //创建类
    class xiu {
        private name;
        private age;
        protected function kang(){
            echo "$this->name";
        }
        protected function sear(){
            echo "this->age";
        }
    }
?>

 创建了一个名为xiu的类，定义了两个属性（name,age）和两个方法（kang,sear）

  • 对象

可以在类的基础上创建实体的特定实例，特定实例称为对象（object）

对象使用new关键字创建

//创建类名为xiu的对象
$xiu = new xiu();
  • 属性

声明属性

在类开始处声明属性，此时可以为属性赋初始值

//声明两个属性（name,age）
class xiu {
    public name = "xiaoming";
    private age = 18;
}

属性可以不需要声明，可以由类对象同时创建和赋值（一般不建议）

调用属性

 与变量不同，属性要使用->操作符引用

xiu类包括属性name、age，如果创建了xiu的类型的对象就可以如下引用其属性

$xiu -> name;
$xiu -> age;

在定义属性类中引用属性时，还是使用 -> 操作符，但此时不使用相应的类名，而是使用$this关键字

$this表示要引用当前类中（要访问或操作的属性所在的类）的属性

function setName($name){
    $this -> name = $name;
}

属性作用域

·public

可以通过在属性前面添加关键字public来声明公共作用域中的属性

class xiu{
    public $name = "user";//创建公共属性$name
}
//公共属性可以由相对应的对象直接操作和访问
$xiu = new xiu();//创建class为xiu的对象
$name = $xiu -> name;
echo "$name";//返回"user"

·private

 private属性只能在定义属性的类中被访问，也不能由其子类使用

class xiu{
    private $name;//设置私有属性
    //私有属性必须使用公共接口来访问
    public function getName($name){//设置公共接口public
        echo $this -> name = $name;//将$name赋值给私有属性name并输出
    }
}
$xiu = new xiu();//创建对象
$xiu -> getName("user");//输出"user"

·protected

 跟函数需要只在函数内部使用的变量一样，类也可以包含只在内部使用的属性称为保护属性（protected）

在继承的子类中也可以访问和操作保护属性（而private不能访问父类）

class xiu {
    protected $name;
}

·final

 设置final作用域时，子类无法覆盖这个值

class xiu {
    final $name;
}

·static

静态类作用域（。。。）

用__set()方法设置属性

class xiu {function __set($rongName,$rongValue){
         echo "$rongName";//返回属性名
         echo "$rongValue";//返回属性值
    }
}
$xiu = new xiu();
$xiu -> value = "user";//设置属性时，会自动调用__set()方法，返回 value user

可以使用以上方法扩展类

class xiu {function __set($rongName,$rongValue){
         $this -> $rongName = $rongValue;
    }
}
$xiu = new xiu();
$xiu -> value = "user";//添加一个属性

用__get()方法获取属性

class xiu {
    private $name = "user";
    function __get($rongName){
        return $this -> $rongName;
    }
}
$xiu = new xiu();
echo $xiu -> name; //获取属性值时，会自动调用__get()方法，返回"user"

创建定制获取方法和设置方法

 自定义获取方法和设置方法

class xiu {
    private $name;
    //获取方法
    public function getName(){
        return $this->name;
    }
    //设置方法
    public function setName($name){
        $this -> name = $name;
    }
}
$xiu = new xiu();
$xiu -> setName("user");//设置属性
echo $xiu -> getName();//获取属性
  • 常量

 在类中可以创建常量，用来表示不会改变的值

class xiu {
    const PI = 3.14159625;//设置常量
}
echo xiu::PI;//输出3.14159625
  • 方法

声明方法

 可以使用与函数相同的语法创建方法，区别：方法声明前面一般会有作用域描述符

class xiu {
    public function fangFa(){
        retuen 2*3;
    }
}

调用方法

class xiu {
    public function fangFa(){//创建方法
        return 2*3;
    }
}
$xiu = new xiu();//创建对象
$kang = $xiu -> fangFa();//调用方法并赋值给$kang
echo $kang;//输出6

方法作用域

·public

公共方法可以在任何位置任何时间访问，在方法前面添加public或不添加任何关键字都可以声明一个公共办法

class xiu {
    public static function fangFa(){//创建公共方法
        echo "添加public关键字";
    }
    function fangFa2(){//创建公共方法
        echo "不添加public关键字";
    }
}
//第一种调用方法
xiu::fangFa();//输出"添加public关键字"
//第二种调用方法
$xiu = new xiu();
$xiu -> fangFa2();//输出"不添加public关键字"

·private

私有方法只能在本类中使用，不能被实例化的对象调用，也不能由子类使用

class xiu {
    private function fangFa(){//创建私有方法
        echo "私有方法";
    }
}

·protected

该类方法可以在本类或子类中使用

class xiu {
    private $name;
    //__construct()允许在实例化一个类之前先执行构造方法
    function __construct($name){
        //verifyEIN()方法验证$sear的语法是否正确
        if($this->verifyEIN($name)){
            echo "$name";
        }
    }
    protected function verifyEIN($name){
        return true;
    }
}
$xiu = new xiu("user");//输出"user"

·abstract

抽象方法（abstract）方法只在父类声明，在子类实现，只有声明为abstract的类可以声明抽象方法

abstract function xiu {
    abstract function kang();
    abstract function sear();
    abstract rong();
}

 

·final

final方法可以防止被子类覆盖

class xiu {
    final function getName(){
        //...
    }
}

·static

 静态方法（。。。）

类型提示

将class为xiu的对象传递给kang()方法

private function kang(xiu $xiu){
    //...
}

构造函数和析构函数

  • 构造函数

 构造函数可以在对象实例化之前自动执行的代码

构造函数可以接受参数，能够在创建对象时赋给特定的对象属性

构造函数可以调用类方法或其他函数

类的构造函数可以调用其他构造函数，包括父类的构造函数

__construct关键字来识别构造函数（关键字前面有两个下划线）

<?php
    class Book{
        private $name;
        private $age;
        private $sex;
        function __construct($name){//声明构造函数
            $this -> setName($name);
            $this -> getAge();
            $this -> getSex();
        }
        private function setName($name){
            $this -> name = $name;
            echo $name;
        }
        private function getAge(){
            echo $this -> age = "20";
        }
        private function getSex(){
            echo $this -> sex = "男";
        }
    }
    $Book = new Book("小明");//输出"小明20男"
?>

调用父类构造函数

<?php
    class Xiu{
        function __construct(){
            echo "输出父类构造函数";
        }
    }
    //创建Xiu的子类，使用关键字extends
    class Kang extends Xiu {
        function __construct(){
            parent :: __construct();//必须使用关键字parent显式调用父类构造函数
            echo "输出子类构造函数";
        }
    }
    $sear = new Kang();//输出"输出父类构造函数输出子类构造函数 "
?>

调用无关的构造函数

（。。。）

<?php
    class xiu {
        function __construct(){
            echo "调用无关构造函数";
        }
    }
    class kang {
        function __construct(){
             new xiu();
        }
    }
    $kang = new kang();//输出"调用无关构造函数 "
?>
  • 析构函数

跟构造函数制订对象创建过程一样，析构函数修改对象撤销过程

__destruct()关键字来识别析构函数（关键字前面有两个下划线）

<?php
    class xiu {
        function __destruct(){
            echo "创建析构函数";
        }
    }
    $xiu = new xiu();//输出"创建析构函数"
?>

脚本结束时，PHP会撤销存储中的所有对象

实例化的类和实例化时创建的信息都留在内存中，不需要显式的声明析构函数

实例化创建了存储在数据库中的数据，就该在对象撤销时撤销这些数据，为此就应该创建一个析构函数

静态类成员

<?php
    class xiu {
        private static $age = 0;//设置静态属性
        function __construct(){
            echo $this -> getAge();
        }
        private function getAge(){
            //静态属性和方法只能使用self关键字和类名来引用
            return self::$age++;//设置属性加1
        }
    }
    $xiu = new xiu();//输出0
    $xiu = new xiu();//输出1
?>

instanceof关键字

 使用instanceof关键字可以确定一个对象是类的实例、类的子类还是实现了某个特定接口

<?php
    //创建两个类
    class xiu{}
    class kang{}
    //创建xiu类对象
    $xiu = new xiu();
    //var_dump()可以打印出类型
    var_dump($xiu instanceof xiu);//对象$xiu是类xiu的对象所以输出true
    var_dump($xiu instanceof kang);//对象$xiu不是类kang的对象所以输出true
?> 

辅助函数

创建类别名

class_alias()函数创建类别名

class xiu {
    function __construct(){
        echo "成功";
    }
}
class_alias("xiu","kang");//将xiu类设置别名kang
$kang = new kang();//输出"成功"

确定类是否存在

class_exists()函数判断上下文是否存在指定的类

class xiu {
    function __construct(){
        echo "成功";
    }
}
echo class_exists("xiu");//因为存在xiu类，所以输出1（true）

确定对象上下文

get_class()函数判断上下文是否存在对象，如果存在返回该对象所属的类名

class xiu {}
$kang = new xiu();
echo get_class($kang);//返回"xiu"

了解类方法

get_class_methods()函数返回指定类中的方法，返回一个数组

class xiu {
    function kang(){}
    function sear(){}
}
print_r( get_class_methods("xiu"));//返回"Array ( [0] => kang [1] => sear ) "

了解类属性

get_class_vars()函数返回指定类中的属性，返回一个关联数组

class xiu {
    public $name = "user";
    public $age = "20";
}
print_r( get_class_vars("xiu"));//返回"Array ( [name] => user [age] => 20 )  "

了解声明类

get_declared_classes()函数返回PHP中所有的类，返回一个数组

print_r(get_declared_classes());

了解对象属性

get_object_vars()函数返回指定对象的已定义的属性和值，如果没有值就返回null，返回一个关联数组

class xiu {
    public $name = "user";
    public $age;
}
$xiu = new xiu();
print_r(get_object_vars($xiu));//"Array ( [name] => user [age] => ) "

确定对象的父类

get_parent_class()函数返回指定类的父类名

class xiu {};
class kang extends xiu{};//创建xiu的子类
echo get_parent_class("kang");//返回"xiu"

确定接口是否存在

interface_exists()函数判断指定接口是否存在

（。。。）

确定对象类型

is_a()函数判断指定对象是否是指定类的对象（或者指定的子类的对象）

class xiu {};
$xiu = new xiu();
var_dump(is_a($xiu,"xiu"));//返回true

确定对象的子类类型

is_subcalss_of()函数判断指定对象是否是指定类的子类对象

class xiu {};
class kang extends xiu{};
$kang = new kang();
var_dump(is_subclass_of($kang,"xiu"));//返回true

确定方法是否存在

method_exists()函数判断指定对象是否包含指定方法

class xiu {
    function getName(){}
}
$xiu = new xiu();
echo method_exists($xiu,"getName");//返回1（true）

PHP不支持的高级OPP特性

 PHP不支持通过函数重载实现多态

PHP不支持多重继承

PHP不支持根据所修改数据类型为操作符赋予新的含义

对象克隆

  • 克隆实例

 在对象前面添加clone关键字来克隆对象，对象的属性值都被继承，克隆的对象还可以重新为原对象赋值

class xiu {
    private $name;
    //为$name定义一个设置方法和获取方法
    function getName(){
        return $this -> name;
    }
    function setName($name){
        $this -> name = $name;
    }
}
$xiu = new xiu();
$xiu -> setName("user");
//用clone克隆$xiu对象
$xiu2 = clone $xiu;
$xiu2 -> setName("kang");
echo $xiu -> getName();//输出user
echo $xiu2 -> getName();//输出kang
  • __clone()方法

 __clone()方法在克隆操作其中执行

class xiu {
    private $name;
    //为$name定义一个设置方法和获取方法
    function getName(){
        return $this -> name;
    }
    function setName($name){
        $this -> name = $name;
    }
    function __clone() {
        $this -> name = "sear";
    }
}
$xiu = new xiu();
$xiu -> setName("user");
//用clone克隆$xiu对象
$xiu2 = clone $xiu;
echo $xiu -> getName();//输出user
echo $xiu2 -> getName();//输出sear

继承

  • 类继承

 类继承通过关键字extends实现

下面的列子是kang类继承xiu类，所以kang类的对象具有xiu类的所有成员和方法

<?php
    class xiu {
        private $name;
        function setName($name) {
            $this -> name = $name;
        }
        function getName(){
            return $this -> name;
        }
    }
    class kang extends xiu {
        function getKang() {
            echo "kang方法";
        }
    }
    $kang = new kang();
    $kang -> setName("修抗");
    echo $kang -> getName();//输出修抗
    $kang -> getKang();//输出kang方法
?>

下面的列子是kang类继承了xiu类，ceo类继承了kang类

所以knag对象拥有xiu类的成员和方法，而ceo对象拥有kang类和xiu类的成员和方法

<?php
    class xiu {}
    class kang extends xiu {}
    class ceo extends kang {}
?>
  • 继承和构造函数

 如果父类有构造函数，而子类没有构造函数，那么子类实例化的时候会执行父类的构造函数

<?php
    class xiu {
        function __construct(){
            echo "执行父类构造函数";
        }
    }
    class kang extends xiu {

    }
    $kang = new kang();//输出"执行父类构造函数"
?>

但如果子类也有构造函数，那不管父类有没有构造函数，只会执行子类的构造函数

<?php
    class xiu {
        function __construct(){
            echo "执行父类构造函数";
        }
    }
    class kang extends xiu {
        function __construct(){
            echo "执行子类构造函数";
        }
    }
    $kang = new kang();//输出"执行子类构造函数"
?>

同时执行父类和子类的构造函数，需要添加 parent::__construct()（如果父类没有构造函数就会去找祖类）

<?php
    class xiu {
        function __construct(){
            echo "执行父类构造函数";
        }
    }
    class kang extends xiu {
        function __construct(){
            parent::__construct();
            echo "执行子类构造函数";
        }
    }
    $kang = new kang();//输出"执行父类构造函数执行子类构造函数"
?>

假设创建新的ceo对象时，需要xiu类和kang类的构造函数都在执行，此时就可以在ceo的构造函数中显式的引用这些函数

class ceo extends kang {
    function __construct(){
        xiu::__construct();
        kang::__construct();
    }
}
  • 继承与延迟静态绑定

self关键词会在编译时而非运行时确定其作用域（运行后编译）

<?php
    class xiu {
         static $name = "xiu";
         static function getName(){
            echo self::$name;
        }
    }
    class kang extends xiu {
         static $name = "kang";
    }
    echo kang::getName();//输出"xiu"
?>

接口

  • 实现一个接口

使用interface关键字创建接口

接口的属性必须是常量

接口的方法必须是public，且不能有函数体

使用implements关键字实现接口类

类必须实现接口中的所有方法

interface xiu{
    const brand = 'siemens';
    public function connect();
}
class kang implements xiu{
    public function connect(){
        echo self::brand;
    }
}
  • 实现多个接口

类可以同时实现多个接口

interface xiu{
    public function connect();
}
interface kang{
    public function contact();
}
class sear implements xiu,kang{
    public function connect(){}
    public function contact(){}
}

抽象类

 抽象类是不能实例化的类，只能被其他类继承

抽象类定义的所有方法都必须在子类实现

abstract class xiu {
    public $name;
    abstract public function kang();
}
class sear extends xiu{
    function kang(){}
}

 对象（end）

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：PHP7变量的内部实现(一)

下一篇：php数组常用函数

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签