本文章是继PHP基础学习笔记（上）的下篇，主要记录php基础知识，资源整合自慕课网。

一、数组定义

数组就是一个键值对组成的语言结构，键类似于酒店的房间号，值类似于酒店房间里存储的东西。

$arr = array();

表示创建一个空数组，并把创建的空数组赋值给变量$arr。

索引数组初始化

PHP有两种数组：索引数组、关联数组。
索引和关联两个词都是针对数组的键而言的。

索引数组是指数组的键是整数的数组，并且键的整数顺序是从0开始，依次类推。

fruit
|香蕉|苹果|雪梨|
|:-|:-:|-:|
|0|1|2|

$fruit = array("苹果","香蕉","菠萝"); 
print_r($fruit);

索引数组赋值

赋值有三种方式:

$arr[0]='苹果';
array('0'=>'苹果');
$arr = array('0'=>'苹果');
if( isset($arr) ) {print_r($arr);}

isset（） 函数是检查 括号内的是否被定义了，定义为null 也表示true。

索引数组内容

$fruit = array('苹果','香蕉');
$fruit0 = $fruit['0'];
print_r($fruit0);//结果为苹果

循环访问索引数组里的值

$fruit=array('苹果','香蕉','菠萝');

// for循环
for($i=0; $i<3; $i++){
    echo '<br>数组第'.$i.'值是：'.$fruit[$i];
}

//foreach循环
foreach($fruit as $key=>$value){
    echo '<br>第'.$key.'值是：';
}

关联数组初始化

// 创建一个关联数组，关联数组的键“orange”，值是“橘子”
$fruit = array(
    // 关联数组赋值
    'apple'=>"苹果",
    'banana'=>"香蕉",
    'pineapple'=>"菠萝"
); 

// 访问关联数组内容
$fruit0 = $fruit['banana'];
print_r($fruit0);

// foreach循环访问关联数组里的值
foreach($fruit as $k=>$v){
    echo '<br>水果的英文键名：'.$k.'，对应的值是：'.$v;

二、类和对象

类是面向对象程序设计的基本概念，通俗的理解类就是对现实中某一个种类的东西的抽象。
如汽车可以抽象为一个类，
属性：名字、轮胎、速度、重量等，
操作方法：换挡、前进、后退等。

// 定义一个汽车类的方法为
class Car {
    $name = '汽车'; //定义属性
    function getName() { //定义方法
        return $this->name; //方法内部可以使用$this伪变量调用对象的属性或者方法
    }
}
// 类是一类东西的结构描述，而对象则是一类东西的一个具体实例，
// 例如汽车这个名词可以理解为汽车的总类，但这辆汽车则是一个具体的汽车对象。

// 对象通过new关键字进行实例化：
$car = new Car();
$car->name = '奥迪A6'; //设置对象的属性值
echo $car->getName();  //调用对象的方法 输出对象的名字

//也可以采用变量来创建
$className = 'Car';
$car = new $className();

//类与对象看起来比较相似，但实际上有本质的区别，
//类是抽象的概念，对象是具体的实例。
//类可以使程序具有可重用性。

对象之类的属性

在类中定义的变量称之为属性，
通常属性跟数据库中的字段有一定的关联，因此也可以称作“字段”。
属性声明是由以下关键字开头。
public：公开的
protected：受保护的
private：私有的

class Car {
    //定义公共属性
    public $name = '汽车';

    //定义受保护的属性
    protected $color = '白色';

    //定义私有属性
    private $price = '100000';
}

默认都为public，外部可以访问。
一般通过->对象操作符来访问对象的属性或者方法，对于静态属性则使用::双冒号进行访问。
当在类成员方法内部调用的时候，可以使用$this伪变量调用当前对象的属性。

$car = new Car();
echo $car->name;   //调用对象的属性
echo $car->color;  //错误 受保护的属性不允许外部调用
echo $car->price;  //错误 私有属性不允许外部调用

受保护的属性与私有属性不允许外部调用，在类的成员方法内部是可以调用的。

class Car{
    private $price = '1000';
    public function getPrice() {
        return $this->price; //内部访问私有属性
​    }
}

定义类的方法

方法就是在类中的function，很多时候我们分不清方法与函数有什么差别，
在面向过程的程序设计中function叫做函数，在面向对象中function则被称之为方法。

同属性一样，类的方法也具有public，protected 以及 private 的访问控制。

被定义为公有的类成员可以在任何地方被访问。
被定义为受保护的类成员则可以被其自身以及其子类和父类访问。
被定义为私有的类成员则只能被其定义所在的类访问。

class Car {
    public function getName() {
        return '汽车';
    }
​}
$car = new Car();
echo $car->getName();

使用关键字static修饰的，称之为静态方法。
静态方法不需要实例化对象，可以通过类名直接调用，操作符为双冒号::。

class Car {
    public static function getName() {
        return '汽车';
    }
​}
echo Car::getName(); //结果为“汽车”

// 静态方法也可以通过变量来进行动态调用

$func = 'getSpeed';
$className = 'Car';
echo $className::$func();  //动态调用静态方法

静态方法中，$this伪变量不允许使用。
可以使用self，parent，static在内部调用静态方法与属性。

class Car {
    private static $speed = 10;
    
    public static function getSpeed() {
        return self::$speed;
    }
    
    public static function speedUp() {
        return self::$speed+=10;
    }
}
class BigCar extends Car {
    public static function start() {
        parent::speedUp();
    }
}

BigCar::start();
echo BigCar::getSpeed();

车辆加速

class Car {
    private static $speed = 10;
    
    public function getSpeed() {
        return self::$speed;
    }
    
    //在这里定义一个静态方法，实现速度累加10

public static function speedUp() {
    return self::$speed+=10;
}

}

$car = new Car();
Car::speedUp();  //调用静态方法加速
echo $car->getSpeed();  //调用共有方法输出当前的速度值

构造函数和析构函数

__construct()定义一个构造函数，具有构造函数的类，
会在每次对象创建的时候调用该函数，因此常用来在对象创建的时候进行一些初始化工作。

class Car {
   function __construct() {
       print "构造函数被调用\n";
   }
}
$car = new Car(); //实例化的时候 会自动调用构造函数__construct，这里会输出一个字符串

在子类中如果定义了__construct则不会调用父类的__construct，
如果需要同时调用父类的构造函数，需要使用parent::__construct()显式的调用。

class Car {
   function __construct() {
       print "父类构造函数被调用\n";
   }
}
class Truck extends Car {
   function __construct() {
       print "子类构造函数被调用\n";
       parent::__construct();
   }
}
$car = new Truck();

同样，PHP5支持析构函数，使用__destruct()进行定义,
析构函数指的是当某个对象的所有引用被删除，或者对象被显式的销毁时会执行的函数。

class Car {
   function __construct() {
       print "构造函数被调用 \n";
   }
   function __destruct() {
       print "析构函数被调用 \n";
   }
}
$car = new Car(); //实例化时会调用构造函数
echo '使用后，准备销毁car对象 \n';
unset($car); //销毁时会调用析构函数

当PHP代码执行完毕以后，会自动回收与销毁对象，因此一般情况下不需要显式的去销毁对象。

访问控制

类属性必须定义为公有、受保护、私有之一。
为兼容PHP5以前的版本，如果采用 var 定义，则被视为公有。

class Car {
    $speed = 10; //错误 属性必须定义访问控制
    public $name;   //定义共有属性
}

类中的方法可以被定义为公有、私有或受保护。
如果没有设置这些关键字，则该方法默认为公有。

class Car {
​    //默认为共有方法
    function turnLeft() {
    }
}

如果构造函数定义成了私有方法，则不允许直接实例化对象了，
这时候一般通过静态方法进行实例化，在设计模式中会经常使用这样的方法来控制对象的创建，
比如单例模式只允许有一个全局唯一的对象。

class Car {
    private function __construct() {
        echo 'object create';
    }

    private static $_object = null;
    public static function getInstance() {
        if (empty(self::$_object)) {
            self::$_object = new Car(); //内部方法可以调用私有方法，因此这里可以创建对象
        }
        return self::$_object;
    }
}
//$car = new Car(); //这里不允许直接实例化对象
$car = Car::getInstance(); //通过静态方法来获得一个实例

对象继承

继承是面向对象程序设计中常用的一个特性，汽车是一个比较大的类，我们也可以称之为基类，
除此之外，汽车还分为卡车、轿车、东风、宝马等，因为这些子类具有很多相同的属性和方法，
可以采用继承汽车类来共享这些属性与方法，实现代码的复用。

class Car {
    public $speed = 0; //汽车的起始速度是0
    
    public function speedUp() {
        $this->speed += 10;
        return $this->speed;
    }
}
//定义继承于Car的Truck类
class Truck extends Car {
    public function speedUp(){
        $this->speed = parent::speedUp() + 50;
    }
}

$car = new Truck();
$car->speedUp();
echo $car->speed;

//结果：60

重载

PHP中的重载指的是动态的创建属性与方法，是通过魔术方法来实现的。

__set，对不存在属性赋值
__get，对不存在属性读取
__isset，判断属性是否设置
__unset，销毁属性

方法的重载通过__call来实现，当调用不存在的方法的时候，
将会转为参数调用__call方法，当调用不存在的静态方法时会使用__callStatic重载。

class Car {
    public $speed = 10;

    //在这里使用重载实现speedDown方法
    public function __call($name, $args) {
        if ($name == 'speedDown') {
            $this->speed -= 10;
        }
    }
}
$car = new Car();
$car->speedDown(); //调用不存在的speedDown方法
echo $car->speed;

// $name 参数是要调用的方法名称。
// $arg 参数是一个枚举数组，包含着要传递给方法 $name 的参数。
// 所有的重载方法都必须被声明为 public。
//这些魔术方法的参数都不能通过引用传递。
//属性重载只能在对象中进行。在静态方式中，这些魔术方法将不会被调用。所以这些方法都不能被声明为 static。

详细：https://www.imooc.com/code/546

高级特性

class Car {
    public $name = 'car';
    
    public function __clone() {
        $obj = new Car();
        $obj->name = $this->name;
    }
}
$a = new Car();
$a->name = 'new car';
$b = clone $a;
if ($a == $b) echo '==';   //true
if ($a === $b) echo '==='; //false

$str = serialize($a); //对象序列化成字符串
echo $str.'<br>';
$c = unserialize($str); //反序列化为对象
var_dump($c);

详细：https://www.imooc.com/code/547

三、正则表达式

正则表达式是对字符串进行操作的一种逻辑公式，
就是用一些特定的字符组合成一个规则字符串，称之为正则匹配模式。

$p = '/apple/';
$str = "apple banna";
if (preg_match($p, $str)) {
    echo 'matched';
}

其中字符串'/apple/'就是一个正则表达式，用于匹配源字符串中是否存在apple字符串。

PHP中使用PCRE库函数进行正则匹配，比如上例中的preg_match用于执行一个正则匹配，
常用来判断一类字符模式是否存在。

基本语法

PCRE库函数中，正则匹配模式使用分隔符与元字符组成，分隔符可以是非数字、非反斜线、非空格的任意字符。经常使用的分隔符是正斜线(/)、hash符号(#) 以及取反符号(~)，例如：

/foo bar/
#^[^0-9]$#
~php~

//如果模式中包含分隔符，则分隔符需要使用反斜杠（\）进行转义。

/http:\/\//

//如果模式中包含较多的分割字符，建议更换其他的字符作为分隔符，也可以采用preg_quote进行转义。

$p = 'http://';
$p = '/'.preg_quote($p, '/').'/';
echo $p;

//分隔符后面可以使用模式修饰符，模式修饰符包括：i, m, s, x等，
//例如使用i修饰符可以忽略大小写匹配：

$str = "Http://www.imooc.com/";
if (preg_match('/http/i', $str)) {
    echo '匹配成功';
}

// 忽略大小写匹配BBC
$p = '/bbc/i';
$str = "BBC是英国的一个电视台";
if (preg_match($p, $str)) {
    echo '匹配成功';
}

元字符与转义

正则表达式中具有特殊含义的字符称之为元字符，常用的元字符有：

\ 一般用于转义字符
^ 断言目标的开始位置(或在多行模式下是行首)
$ 断言目标的结束位置(或在多行模式下是行尾)
. 匹配除换行符外的任何字符(默认)
[ 开始字符类定义
] 结束字符类定义
| 开始一个可选分支
( 子组的开始标记
) 子组的结束标记
? 作为量词，表示 0 次或 1 次匹配。位于量词后面用于改变量词的贪婪特性。 (查阅量词)

  • 量词，0 次或多次匹配
  • 量词，1 次或多次匹配
    { 自定义量词开始标记
    } 自定义量词结束标记

//下面的\s匹配任意的空白符，包括空格，制表符，换行符。[\s]代表非空白符。[\s]+表示一次或多次匹配非空白符。

$p = '/^我[^\s]+(苹果|香蕉)$/';
$str = "我喜欢吃苹果";
if (preg_match($p, $str)) {
    echo '匹配成功';
}

元字符具有两种使用场景，一种是可以在任何地方都能使用，另一种是只能在方括号内使用，在方括号内使用的有：

\ 转义字符
^ 仅在作为第一个字符(方括号内)时，表明字符类取反

  • 标记字符范围

其中^在反括号外面，表示断言目标的开始位置，但在方括号内部则代表字符类取反，方括号内的减号-可以标记字符范围，例如0-9表示0到9之间的所有数字。

//下面的\w匹配字母或数字或下划线。
$p = '/[\w\.\-]+@[a-z0-9\-]+\.(com|cn)/';
$str = "我的邮箱是Spark.eric@imooc.com";
preg_match($p, $str, $match);
echo $match[0];

//匹配str中的电话
$p = '/\d+\-\d+/';
$str = "我的电话是010-12345678";
preg_match($p, $str, $match);
echo $match[0];

贪婪模式与懒惰模式

正则表达式中每个元字符匹配一个字符，当使用+之后将会变的贪婪，它将匹配尽可能多的字符，
但使用问号?字符时，它将尽可能少的匹配字符，既是懒惰模式。

贪婪模式：在可匹配与可不匹配的时候，优先匹配

//下面的\d表示匹配数字
$p = '/\d+\-\d+/';
$str = "我的电话是010-12345678";
preg_match($p, $str, $match);
echo $match[0]; //结果为：010-12345678

懒惰模式：在可匹配与可不匹配的时候，优先不匹配

$p = '/\d?\-\d?/';
$str = "我的电话是010-12345678";
preg_match($p, $str, $match);
echo $match[0];  //结果为：0-1

当我们确切的知道所匹配的字符长度的时候，可以使用{}指定匹配字符数

$p = '/\d{3}\-\d{8}/';
$str = "我的电话是010-12345678";
preg_match($p, $str, $match);
echo $match[0]; //结果为：010-12345678

匹配str中的姓名

$p = '/name:([\w\s]+)/';
$str = "name:steven jobs";
preg_match($p, $str, $match);
echo $match[1]; //结果为：steven jobs

正则表达式匹配

//正则匹配，并输出邮箱地址,匹配email的方法还有有很多
$subject = "my email is spark@imooc.com";
$pattern = '/[\w\-]+@\w+\.\w+/';
preg_match($pattern, $subject, $matches);
echo $matches[0];

详细：https://www.imooc.com/code/562

查找所有匹配结果

preg_match只能匹配一次结果，但很多时候我们需要匹配所有的结果，
preg_match_all可以循环获取一个列表的匹配结果数组。

$str = "<ul>
            <li>item 1</li>
            <li>item 2</li>
        </ul>";
//在这里补充代码，实现正则匹配所有li中的数据

$p = "/<li>(.*)<\/li>/i";//解释下这个正则：
//后面的i表示不区分大小写，<li>(.*?)<\/li>表示li标签内的匹配的()内的值有多少，
括号内的.表示所有单字符,*表示数量为0个或者多个。也就是li标签内有字符就显示出来
preg_match_all($p, $str, $matches);
print_r($matches[1]);

结果：
Array
(
    [0] => item 1
    [1] => item 2
)

详细：https://www.imooc.com/code/563

正则表达式的搜索和替换

$str = '主要有以下几个文件：index.php, style.css, common.js';
//将目标字符串$str中的文件名替换后增加em标签

$p = '/\w+\.\w+/i';
$str = preg_replace($p, '<em>$0</em>', $str);
echo $str;
结果：
主要有以下几个文件：index.php, style.css, common.js

常用案例

$user = array(
    'name' => 'spark1985',
    'email' => 'spark@imooc.com',
    'mobile' => '13312345678'
);
//进行一般性验证
if (empty($user)) {
    die('用户信息不能为空');
}
if (strlen($user['name']) < 6) {
    die('用户名长度最少为6位');
}
//用户名必须为字母、数字与下划线
if (!preg_match('/^\w+$/i', $user['name'])) {
    die('用户名不合法');
}
//验证邮箱格式是否正确
if (!preg_match('/^[\w\.]+@\w+\.\w+$/i', $user['email'])) {
    die('邮箱不合法');
}
//手机号必须为11位数字，且为1开头
if (!preg_match('/^1\d{10}$/i', $user['mobile'])) {
    die('手机号不合法');
}
echo '用户信息验证成功';

四、cookie

Cookie是存储在客户端浏览器中的数据，我们通过Cookie来跟踪与存储用户数据。
一般情况下，Cookie通过HTTP headers从服务端返回到客户端。
多数web程序都支持Cookie的操作，因为Cookie是存在于HTTP的标头之中，
所以必须在其他信息输出以前进行设置，类似于header函数的使用限制。

PHP通过setcookie函数进行Cookie的设置，任何从浏览器发回的Cookie，PHP都会自动的将他存储在$_COOKIE的全局变量之中，因此我们可以通过$_COOKIE['key']的形式来读取某个Cookie值。

PHP中的Cookie具有非常广泛的使用，经常用来存储用户的登录信息，购物车等，且在使用会话Session时通常使用Cookie来存储会话id来识别用户，Cookie具备有效期，当有效期结束之后，Cookie会自动的从客户端删除。同时为了进行安全控制，Cookie还可以设置域跟路径，我们会在稍后的章节中详细的讲解他们。

setcookie('test', time());
ob_start();
print_r($_COOKIE); 
$content = ob_get_contents();
$content = str_replace(" ", '&nbsp;', $content);
ob_clean();
header("content-type:text/html; charset=utf-8");
echo '当前的Cookie为：<br>';
echo nl2br($content);

设置cookie

PHP设置Cookie最常用的方法就是使用setcookie函数，setcookie具有7个可选参数，

我们常用到的为前5个：

name（ Cookie名）可以通过$_COOKIE['name'] 进行访问
value（Cookie的值）
expire（过期时间）Unix时间戳格式，默认为0，表示浏览器关闭即失效
path（有效路径）如果路径设置为'/'，则整个网站都有效
domain（有效域）默认整个域名都有效，如果设置了'www.imooc.com',则只在www子域中有效

$value = 'test';
setcookie("TestCookie", $value);
setcookie("TestCookie", $value, time()+3600);  //有效期一小时
setcookie("TestCookie", $value, time()+3600, "/path/", "imooc.com"); //设置路径与域

PHP中还有一个设置Cookie的函数setrawcookie，setrawcookie跟setcookie基本一样，
唯一的不同就是value值不会自动的进行urlencode，因此在需要的时候要手动的进行urlencode。

setrawcookie('cookie_name', rawurlencode($value), time()+60*60*24*365);

因为Cookie是通过HTTP标头进行设置的，所以也可以直接使用header方法进行设置。

header("Set-Cookie:cookie_name=value");

设置一个名为test的Cookie

$value = time();
setcookie('test', $value); 
if (isset($_COOKIE['test'])) {
    echo 'success';
}

删除与过期时间

setcookie('test', time());
//在这里试着删除test的cookie值
setcookie('test', '', time()-1); 
var_dump($_COOKIE);

将cookie的过期时间设置到当前时间之前，则该cookie会自动失效，也就达到了删除cookie的目的。
之所以这么设计是因为cookie是通过HTTP的标头来传递的，客户端根据服务端返回的Set-Cookie段来进行cookie的设置，如果删除cookie需要使用新的Del-Cookie来实现，则HTTP头就会变得复杂，
实际上仅通过Set-Cookie就可以简单明了的实现Cookie的设置、更新与删除。

了解原理以后，我们也可以直接通过header来删除cookie。

header("Set-Cookie:test=1393832059; expires=".gmdate('D, d M Y H:i:s \G\M\T', time()-1));

这里用到了gmdate，用来生成格林威治标准时间，以便排除时差的影响。

有效路径

cookie中的路径用来控制设置的cookie在哪个路径下有效，默认为'/'，
在所有路径下都有，当设定了其他路径之后，则只在设定的路径以及子路径下有效，例如：

setcookie('test', time(), 0, '/path');

上面的设置会使test在/path以及子路径/path/abc下都有效，但是在根目录下就读取不到test的cookie值。

一般情况下，大多是使用所有路径的，只有在极少数有特殊需求的时候，会设置路径，
这种情况下只在指定的路径中才会传递cookie值，可以节省数据的传输，增强安全性以及提高性能。

当我们设置了有效路径的时候，不在当前路径的时候则看不到当前cookie。

setcookie('test', '1',0, '/path');  
var_dump($_COOKIE['test']);

session与cookie的异同

cookie将数据存储在客户端，建立起用户与服务器之间的联系，
通常可以解决很多问题，但是cookie仍然具有一些局限：

cookie相对不是太安全，容易被盗用导致cookie欺骗
单个cookie的值最大只能存储4k
每次请求都要进行网络传输，占用带宽

session是将用户的会话数据存储在服务端，没有大小限制，通过一个session_id进行用户识别，PHP默认情况下session id是通过cookie来保存的，因此从某种程度上来说，seesion依赖于cookie。但这不是绝对的，session id也可以通过参数来实现，只要能将session id传递到服务端进行识别的机制都可以使用session。

使用session

//先执行session_start方法开启session
session_start();
//设置一个session，然后通过全局变量$_SESSION进行session的读写
$_SESSION['test'] = time();
//显示当前的session_id
echo "session_id:".session_id();
echo "<br>";

//读取session值
echo $_SESSION['test'];
// var_dump($_SESSION);

//删除与销毁一个session
unset($_SESSION['test']);
echo "<br>";
var_dump($_SESSION);
//如果要删除所有的session，可以使用session_destroy函数销毁当前session，
//session_destroy会删除所有数据，但是session_id仍然存在。

session_start();
$_SESSION['name'] = 'jobs';
$_SESSION['time'] = time();
session_destroy();

//session_destroy并不会立即的销毁全局变量$_SESSION中的值，只有当下次再访问的时候，
//$_SESSION才为空，因此如果需要立即销毁$_SESSION，可以使用unset函数。

session_start();
$_SESSION['name'] = 'jobs';
$_SESSION['time'] = time();
unset($_SESSION);
session_destroy(); 
var_dump($_SESSION); //此时已为空

//如果需要同时销毁cookie中的session_id，通常在用户退出的时候可能会用到，
//则还需要显式的调用setcookie方法删除session_id的cookie值。

session会自动的对要设置的值进行encode与decode，
因此session可以支持任意数据类型，包括数据与对象等。

session_start();
SESSION[′ary′]=array(′name′=>′jobs′);_SESSION['ary'] = array('name' => 'jobs'); _SESSION['obj'] = new stdClass();
var_dump($_SESSION);
默认情况下，session是以文件形式存储在服务器上的，因此当一个页面开启了session之后，会独占这个session文件，这样会导致当前用户的其他并发访问无法执行而等待。可以采用缓存或者数据库的形式存储来解决这个问题，

session来存储用户的登录信息

session可以用来存储多种类型的数据，因此具有很多的用途，
常用来存储用户的登录信息，购物车数据，或者一些临时使用的暂存数据等。

用户在登录成功以后，通常可以将用户的信息存储在session中，
一般的会单独的将一些重要的字段单独存储，然后所有的用户信息独立存储。

$_SESSION['uid'] = $userinfo['uid'];
$_SESSION['userinfo'] = $userinfo;

一般来说，登录信息既可以存储在sessioin中，也可以存储在cookie中，
他们之间的差别在于session可以方便的存取多种数据类型，而cookie只支持字符串类型，
同时对于一些安全性比较高的数据，cookie需要进行格式化与加密存储，而session存储在服务端则安全性较高。

session_start();
//假设用户登录成功获得了以下用户数据
$userinfo = array(
    'uid'  => 10000,
    'name' => 'spark',
    'email' => 'spark@imooc.com',
    'sex'  => 'man',
    'age'  => '18'
);
header("content-type:text/html; charset=utf-8");

/* 将用户信息保存到session中 */
$_SESSION['uid'] = $userinfo['uid'];
$_SESSION['name'] = $userinfo['name'];
$_SESSION['userinfo'] = $userinfo;

//* 将用户数据保存到cookie中的一个简单方法 */
$secureKey = 'imooc'; //加密密钥
$str = serialize($userinfo); //将用户信息序列化
//用户信息加密前
$str = base64_encode(mcrypt_encrypt(MCRYPT_RIJNDAEL_256, md5($secureKey), $str, MCRYPT_MODE_ECB));
//用户信息加密后
//将加密后的用户数据存储到cookie中
setcookie('userinfo', $str);

//当需要使用时进行解密
$str = mcrypt_decrypt(MCRYPT_RIJNDAEL_256, md5($secureKey), base64_decode($str), MCRYPT_MODE_ECB);
$uinfo = unserialize($str);
echo "解密后的用户信息：<br>";
print_r($uinfo);

结果：
解密后的用户信息：
Array
(
    [uid] => 10000
    [name] => spark
    [email] => spark@imooc.com
    [sex] => man
    [age] => 18
)

五、文件系统

读取文件内容

$content = file_get_contents('./test.txt');
// file_get_contents，可以将整个文件全部读取到一个字符串中

$content = file_get_contents('./test.txt', null, null, 100, 500);
//可通过参数控制读取内容的开始点以及长度。

echo $content;

PHP也提供类似于C语言操作文件的方法，使用fopen，fgets，fread等方法，
fgets可以从文件指针中读取一行，freads可以读取指定长度的字符串。

$fp = fopen('./text.txt', 'rb');
while(!feof($fp)) {
    echo fgets($fp); //读取一行
}
fclose($fp);
 
$fp = fopen('./text.txt', 'rb');
$contents = '';
while(!feof($fp)) {
    $contents .= fread($fp, 4096); //一次读取4096个字符
}
fclose($fp);

使用fopen打开的文件，最好使用fclose关闭文件指针，以避免文件句柄被占用。

判断文件是否存在

is_file与file_exists.

file_exists:

//判断文件是否存在，同时也可以判断目录是否存在
$filename = './test.txt';
if (file_exists($filename)) {
    echo file_get_contents($filename);
}

is_file:

//is_file是确切的判断给定的路径是否是一个文件,从函数名可以看出
$filename = './test.txt';
if (is_file($filename)) {
    echo file_get_contents($filename);
}

is_readable与is_writeable更加精确
在文件是否存在的基础上，判断文件是否可读与可写。

//可写
$filename = './test.txt';
if (is_writeable($filename)) {
    file_put_contents($filename, 'test');
}
//可读
if (is_readable($filename)) {
    echo file_get_contents($filename);
}

取得文件的修改时间

文件有很多元属性，包括：文件的所有者、创建时间、修改时间、最后的访问时间等。

fileowner：获得文件的所有者
filectime：获取文件的创建时间
filemtime：获取文件的修改时间
fileatime：获取文件的访问时间

其中最常用的是文件的修改时间，通过文件的修改时间，
可以判断文件的时效性，经常用在静态文件或者缓存数据的更新。

mtime=filemtime(mtime = filemtime(filename);
echo '修改时间：'.date('Y-m-d H:i:s', filemtime($filename));

$filename = '/data/webroot/usercode/code/resource/test.txt';
echo '所有者：'.fileowner($filename).'<br>';
echo '创建时间：'.filectime($filename).'<br>';
echo '修改时间：'.filemtime($filename).'<br>';
echo '最后访问时间：'.fileatime($filename).'<br>';

//给$mtime赋值为文件的修改时间
$mtime = filemtime($filename);
//通过计算时间差 来判断文件内容是否有效
if (time() - $mtime > 3600) {
    echo '<br>缓存已过期';
} else {
    echo file_get_contents($filename);
}

取得文件的大小

$filename = '/data/webroot/usercode/resource/test.txt';
echo filesize($filename);
//没法通过简单的函数来取得目录的大小，目录的大小是该目录下所有子目录以及文件大小的总和，
//因此需要通过递归的方法来循环计算目录的大小。

详细：https://www.imooc.com/code/578

写入内容到文件

$filename = '/data/webroot/usercode/code/test2.txt';
$fp = fopen($filename, 'w');
fwrite($fp, 'hello world'); 
fclose($fp); 

// 或者
$fp = fopen('./test.txt', 'w');
fwrite($fp, 'hello');
fwrite($fp, 'world');
fclose($fp);

删除文件

跟Unix系统命令类似，PHP使用unlink函数进行文件删除。

unlink($filename);

删除文件夹使用rmdir函数，文件夹必须为空，如果不为空或者没有权限则会提示失败。

rmdir($dir);

如果文件夹中存在文件，可以先循环删除目录中的所有文件，然后再删除该目录，循环删除可以使用glob函数遍历所有文件。

foreach (glob("*") as $filename) {
   unlink($filename);
}

六、异常处理

从PHP5开始，PHP支持异常处理，异常抛出之后，后面的代码将不会再被执行。
当代码中使用了try catch的时候，抛出的异常会在catch中捕获，否则会直接中断。

基本语法
        try{
            //可能出现错误或异常的代码
            //catch表示捕获，Exception是php已定义好的异常类
        } catch(Exception $e){
            //对异常处理，方法：
                //1、自己处理
                //2、不处理，将其再次抛出
        }

//每一个 "throw" 必须对应至少一个 "catch"，当然可以对应多个"catch"
//Catch - "catch" 代码块会捕获异常，并创建一个包含异常信息的对象。

创建可抛出一个异常的函数
function checkNum($number){
     if($number>1){
         throw new Exception("异常提示-数字必须小于等于1");
     }
     return true;
 }

//在 "try" 代码块中触发异常
 try{
     checkNum(2);
     //如果异常被抛出，那么下面一行代码将不会被输出
     echo '如果能看到这个提示，说明你的数字小于等于1';
 }catch(Exception $e){
     //捕获异常
     echo '捕获异常: ' .$e->getMessage();
 }

 检测文件是否存在
$filename = 'test.txt';
try {
    if (!file_exists($filename)) {
      throw new Exception('文件不存在');
    }
} catch(Exception $e) {
    echo $e->getMessage();
}

异常处理类

Exception具有几个基本属性与方法，其中包括了：

message 异常消息内容
code 异常代码
file 抛出异常的文件名
line 抛出异常在该文件的行数

其中常用的方法有：

getTrace 获取异常追踪信息
getTraceAsString 获取异常追踪信息的字符串
getMessage 获取出错信息

class MyException extends Exception {
    function getInfo() {
        return '自定义错误信息';
    }
}

try {
    throw new MyException('error');
} catch(Exception $e) {
    echo $e->getInfo();
}

详细：https://www.imooc.com/code/601

捕获异常信息

在实际应用中，不会轻易的抛出异常，只有在极端情况或者非常重要的情况下，才会抛出异常，
抛出异常，可以保障程序的正确性与安全，避免导致不可预知的bug。

//一般的异常处理流程代码为：
try {
    throw new Exception('wrong');
} catch(Exception $ex) {
    echo 'Error:'.$ex->getMessage().'<br>';
    echo $ex->getTraceAsString().'<br>';
}
echo '异常处理后，继续执行其他代码';

获取错误发生的所在行

在实际应用中，我们通常会获取足够多的异常信息，然后写入到错误日志中。
通过我们需要将报错的文件名、行号、错误信息、异常追踪信息等记录到日志中，以便调试与修复问题。

try {
    throw new Exception('wrong');
} catch(Exception $ex) {
    $msg = 'Error:'.$ex->getMessage()."\n";
    $msg.= $ex->getTraceAsString()."\n";
    $msg.= '异常行号：'.$ex->getLine()."\n";
    $msg.= '所在文件：'.$ex->getFile()."\n";
    //将异常信息记录到日志中
 PHP异常处理之   file_put_contents('error.log', $msg);
}

扩展学习：
PHP进阶篇-函数 ：http://www.imooc.com/learn/737
PHP进阶篇-日期时间函数：http://www.imooc.com/learn/698

来源：慕课网，内容持续更新中...