一、数组
1、数组定义
数组就是一个键值对组成的语言结构，键类似于酒店的房间号，值类似于酒店房间里存储的东西。
$arr=array();表示创建一个空数组，并把创建的空数组赋值给变量$arr。
print_r($arr)打印数组
2、PHP数组之索引数组初始化
php数组，根据索引值的不同分为两种：索引数组、关联数组。
索引和关联两个词都是针对数组的键而言的。
索引数组是指数组的键是整数的数组，并且键的整数顺序是从0开始，依次类推。
$fruit = array("苹果","香蕉","菠萝");注意数组的键是从0开始的。可以使用print_r($fruit);语句输出数组键及对应的值。
$fruit=array("苹果","香蕉","菠萝");
print_r($fruit); //Array([0] => 苹果[1] => 香蕉[2] => 菠萝)
?>
3、PHP数组之索引数组赋值
索引数组赋值有三种方式:
第一种：用数组变量的名字后面跟一个中括号的方式赋值，当然，索引数组中，中括号内的键一定是整数。比如，$arr[0]='苹果';
第二种：用array()创建一个空数组，使用=>符号来分隔键和值，左侧表示键，右侧表示值。当然，索引数组中，键一定是整数。比如，array('0'=>'苹果');
第三种：用array()创建一个空数组，直接在数组里用英文的单引号'或者英文的双引号"赋值，数组会默认建立从0开始的整数的键。比如array('苹果');这个数组相当于array('0'=>'苹果');
4、PHP数组之访问索引数组内容
有的时候我们需要把数组中的内容也就是值取出来该怎么办呢？用数组变量的名字后跟的中括号中的键，来访问数组中的值。
$fruit = array('苹果','香蕉');
$fruit0 = $fruit['0'];
print_r($fruit0);//结果为苹果
?>
上面代码的作用：先把一个数组$fruit第一个值取出来然后赋给一个变量$fruit0，最后输出变量值。
5、PHP数组之for循环访问索引数组里的值
for循环可以将数组里的所有值都访问到，下面我们展示下，用for循环访问索引数组里的值。
$fruit=array('苹果','香蕉','菠萝');
for($i=0; $i<3; $i++){
echo '
数组第'.$i.'值是：'.$fruit[$i];
}
6、PHP数组之foreach循环访问索引数组里的值
foreach循环可以将数组里的所有值都访问到，下面我们展示下，用foreach循环访问索引数组里的值。
$fruit=array('苹果','香蕉','菠萝');
foreach($fruit as $k=>$v){
echo '
第'.$k.'值是：'.$v;
}
?>
7、PHP数组之关联数组初始化
关联数组是指数组的键是字符串的数组。
$fruit = array(
'apple'=>"苹果",
'banana'=>"香蕉",
'pineapple'=>"菠萝"
);
可以使用print_r($fruit);语句输出数组键及对应的值。
8、PHP数组之关联数组赋值
关联数组赋值有两种方式:
第一种：用数组变量的名字后面跟一个中括号的方式赋值，当然，关联数组中，中括号内的键一定是字符串。比如，$arr['apple']='苹果';
第二种：用array()创建一个空数组，使用=>符号来分隔键和值，左侧表示键，右侧表示值。当然，关联数组中，键一定是字符串。比如，array('apple'=>'苹果');
9、PHP数组之访问关联数组内容
用数组变量的名字后跟中括号+键的方式来访问数组中的值，键使用单引号或者双引号括起来。
$fruit = array('apple'=>"苹果",'banana'=>"香蕉",'pineapple'=>"菠萝");
$fruit0 =$fruit['banana'];
print_r($fruit0);
10、PHP数组之foreach循环访问关联数组里的值
$fruit=array('apple'=>"苹果",'banana'=>"香蕉",'pineapple'=>"菠萝");
foreach($fruit as $k=>$v){
echo '
水果的英文键名：'.$k.'，对应的值是：'.$v;
}
11.使用range( )建立一个包含指定范围单元的数组
$num=range(1,10);
print_r($num);
$letter=range("a","z");
print_r($letter);
12.unset( )删除数组元素
$arr=array("city1"=>"北京","city2"=>"上海","city3"=>"深圳");
unset($arr["city3"]);
print_r($arr);//打印新的数组
13.count( )取得数组的长度
$arr=array("city1"=>"北京","city2"=>"上海","city3"=>"深圳");
echo count($arr);
14.in_array("北京",$arr)检查数组中是否包含某个值
第一个参数是要判断的值，第二个参数是要判断的数组，返回值是一个布尔值
arr=array("city1"=>"北京","city2"=>"上海","city3"=>"深圳");
var_dump(in_array("北京", $arr));
15.sort()根据首字母来进行正向的排序,根据值进行排序
$arr=array("a","z","g","t");
sort($arr);
print_r($arr);
rsort()根据首字母来进行反向的排序,根据值进行排序
16.根据索引进行排序
ksort()根据索引进行升序排序
krsort()根据索引进行降序排序
$arr=array("c"=>"d2c","g"=>"ff545g","f"=>"5435f","a"=>"8675a");
ksort($arr);//ksort()根据索引进行升序排序
print_r($arr);
krsort($arr);//krsort()根据索引进行降序排序
print_r($arr);
17.二维数组
$arr=array("city1"=>"北京","city2"=>"上海","city3"=>array("拉萨","普罗旺斯"));
foreach($arr as $k => $v) {
if($k != "city3"){
echo "
";
echo $v;
}else{
//双层循环数组
foreach($v as $kk=>$vv){
echo "
";
echo $vv;}}}
//循环多维数组
//引入文件
include "adress.php";
foreach($adress as $k => $v) {
echo"省名：". $v["province_name"]."
";
if(!empty($v["city"])) {
foreach($v["city"] as $key => $val) {
echo" 市名：". $val["city_name"]."
";
if(!empty($val["area"])) {
foreach($val["area"] as $kk => $vv) {
echo" 区名：". $vv."
";}}}}}
二、函数
1、php自定义函数
PHP内置了超过1000个函数，因此函数使得PHP成为一门非常强大的语言。大多数时候我们使用系统的内置函数就可以满足需求，但是自定义函数通过将一组代码封装起来，使代码进行复用，程序结构与逻辑更加清晰。
PHP函数的定义方式：
1.使用关键字“function”开始
2.函数名可以是字母或下划线开头：function name()
3.在大括号中编写函数体：
function name() {
echo 'Eric';
}
通过上面的步骤，我们就定义了一个简单的函数，当我们需要的时候，就可以在代码中调用这个函数，调用方法为函数名+参数，例如：name();
调用的时候不区分大小写，不过在调用函数时，通常使用其在定义时的形式。
函数名称是由字母或下划线开始，中间可以包含数字
php不支持函数重载，所以自定义函数不能和内置函数重名
不能在一个文件中自定义同名的函数
局部变量：函数体内定义的变量为局部变量，只在函数体内可见
局部变量的作用域：从声明它的那条语句开始到函数结束
2、php函数的参数
PHP的函数可以没有参数，也可以有若干个参数，多个参数称之为参数列表，采用逗号进行分割，参数类似于一个变量，调用时用来传递数据到函数体中。通过传递参数可以使函数实现对参数的运算，得到我们想要的结果。
参数的变量名可以自由指定，但最好能够表达相关的意思，常用的设定参数的方法为：
function sum($a, $b) {
return $a+$b;
}
支持默认参数，如果不给参数，就会调用默认的参数
function test2($b="123"){
echo $b;
}
test2();
传值
$d=10;
function test3($c){$c=5;}
test($d);
echo $d;//打印结果是10，只传值，不传址
传址
$e=10;
function test4(&$f){$f=5;}
test4($e);//打印结果是5，加了&，引用同一个地址
echo $e;
3、php函数之返回值
使用return关键字可以使函数返回值，可以返回包括数组和对象的任意类型，如果省略了 return，则默认返回值为 NULL。
function add($a) {
return $a+1;
}
$b = add(1);
返回语句会立即中止函数的运行，并且将控制权交回调用该函数的代码行，因此下面函数的返回值跟上面的函数是一样的。
function add($a) {
return $a+1;
$a = 10;
return $a+20;
}
$b = add(1);
函数不能返回多个值，但可以通过返回一个数组来得到类似的效果。
function numbers() {
return array(1, 2, 3);
}
list ($one, $two, $three) = numbers();
4、PHP函数之可变函数
所谓可变函数，即通过变量的值来调用函数，因为变量的值是可变的，所以可以通过改变一个变量的值来实现调用不同的函数。经常会用在回调函数、函数列表，或者根据动态参数来调用不同的函数。可变函数的调用方法为变量名加括号。
function name() {
echo 'jobs';
}
$func = 'name';
$func(); //调用可变函数
可变函数也可以用在对象的方法调用上。
class book {
function getName() {
return 'bookname';
}
}
$func = 'getName';
$book = new book();
$book->$func();
5、PHP函数之内置函数
内置函数指的是PHP默认支持的函数，PHP内置了很多标准的常用的处理函数，包括字符串处理、数组函数、文件处理、session与cookie处理等。
我们先拿字符串处理函数来举例，通过内置函数str_replace可以实现字符串的替换。下面的例子将“jobs”替换成“steven jobs”：
$str = 'i am jobs.';
$str1 = str_replace('jobs', 'steven jobs', $str);
echo $str1; //结果为“i am steven jobs”
另外一些函数是通过其他扩展来支持的，比如mysql数据库处理函数，GD图像处理函数，邮件处理函数等，PHP默认加载了一些常用的扩展库，我们可以安装或者加载其他扩展库来增加PHP的处理函数。
6 、PHP函数之判断函数是否存在
当我们创建了自定义函数，并且了解了可变函数的用法，为了确保程序调用的函数是存在的，经常会先使用function_exists判断一下函数是否存在。同样的method_exists可以用来检测类的方法是否存在。
function func() {
}
if (function_exists('func')){
echo "存在";
}
类是否定义可以使用class_exists。
lass MyClass{
}
// 使用前检查类是否存在
if (class_exists('MyClass')) {
$myclass = new MyClass();
}
PHP中有很多这类的检查方法，例如文件是否存在file_exists等。
$filename = 'test.txt';
if (!file_exists($filename)) {
echo $filename . ' not exists.';
}
7.函数的作用域,函数里面取不到外面的东西，作用域在函数内部有效，函数的里面的东西外面也取不到
$aa=10;//外面定义一个变量，在函数里面是访问不到的，可以通过传参取到外面的变量
function ccc(){
//echo $aa;
}
ccc();
通过global，取到外面的变量
$aa=10;
function cccc(){
global $aa;//申明$aa是一个全局变量
echo $aa;
}
cccc();
超全局变量,用$GLOBALS设置
function test(){
$a=10;
$GLOBALS["a"]=$a;//超全局变量
}
test();
echo $GLOBALS['a'];
详解global和$GLOBALS[]的区别：
1.$GLOBALS[‘var’]是外部的全局变量本身
2.global $var是外部$var的同名引用或者指针
$var1 = 1;
$var2 = 2;
function test(){
$GLOBALS[‘var2′] = &$GLOBALS[‘var1′];
}
test();
echo $var2;//正常打印结果为1
?>
$var1 = 1;
$var2 = 2;
function test(){
global $var1,$var2;
$var2 = &$var1;
}
test();
echo $var2;//意外打印结果为2.为什么会打印结果为2呢？其实就是因为$var1的引用指向了$var2的引用地址。导致实质的值没有改变。
?>
我们再来看一个例子吧。
$var1 = 1;
function test(){
unset($GLOBALS[‘var1′]);
}
test();
echo $var1;//因为$var1被删除了，所以什么东西都没有打印
?>
$var1 = 1;
function test(){
global $var1;
unset($var1);
}
test();
echo $var1;//意外的打印了1。证明删除的只是别名|引用，其本身的值没有受到任何的改变.
明白了吧？也就是说global $var其实就是$var = &$GLOBALS[‘var’]。调用外部变量的一个别名而已
?>
8.函数递归，方法一
$num=1;
function test($num){
$num++;
if($num<5){
echo $num;
test($num);//递归，满足条件调用函数
}else{
return;
}
}
test($num);//把$num当做参数传到函数里面去
用递归处理阶乘问题
function factorial($num){
if($num>0){
return $num*factorial($num-1);
}else{
return 1;}}
echo factorial(5);//调用，打印
9.函数递归，方法二，静态变量
静态变量（每次调用完成后会记住上一次的值）,也叫常驻内存，关键字是static
function test(){
static $num=1;
$num++;
if($num<5){
echo $num;
test();
}else{
return;}}
test();
三、PHP类与面向对象
1.php类和对象
类是面向对象程序设计的基本概念，通俗的理解类就是对现实中某一个种类的东西的抽象， 比如汽车可以抽象为一个类，汽车拥有名字、轮胎、速度、重量等属性，可以有换挡、前进、后退等操作方法。
通常定义一个汽车类的方法为：
class Car {
var $name = '汽车';
function getName() {
return $this->name;
}}
类是一类东西的结构描述，而对象则是一类东西的一个具体实例，例如汽车这个名词可以理解为汽车的总类，但这辆汽车则是一个具体的汽车对象。
对象通过new关键字进行实例化：
$car = new Car();
echo $car->getName();
类与对象看起来比较相似，但实际上有本质的区别，类是抽象的概念，对象是具体的实例。类可以使程序具有可重用性。
//定义一个类
class Car {
var $name = '汽车';
function getName() {
return $this->name;
}
}
//实例化一个car对象
$car = new Car();
$car->name = '奥迪A6'; //设置对象的属性值
echo $car->getName(); //调用对象的方法 输出对象的名字
?>
2.PHP类和对象之创建一个对象
类的定义方法，类通过关键字class开头，然后是类名与花括号，在花括号中定义类的属性与方法。类名必须是字母或下划线开头，后面紧跟若干个字母、数字或下划线，类名最好能够表意，可以采用名词或者英文单词。
/定义一个类
class Car {
//定义属性
public $name = '汽车';
//定义方法
public function getName() {
//方法内部可以使用$this伪变量调用对象的属性或者方法
return $this->name;
}
}
要创建一个类的实例，可以使用new关键字创建一个对象。
$car = new Car();
//也可以采用变量来创建
$className = 'Car';
$car = new $className();
3.PHP类和对象之类的属性
在类中定义的变量称之为属性，通常属性跟数据库中的字段有一定的关联，因此也可以称作“字段”。属性声明是由关键字 public，protected 或者 private 开头，后面跟一个普通的变量声明来组成。属性的变量可以设置初始化的默认值，默认值必须是常量。
访问控制的关键字代表的意义为：
public：公开的
protected：受保护的
private：私有的
class Car {
//定义公共属性
public $name = '汽车';
//定义受保护的属性
protected $corlor = '白色';
//定义私有属性
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; //内部访问私有属性
}}
4.PHP类和对象之定义类的方法
方法就是在类中的function，很多时候我们分不清方法与函数有什么差别，在面向过程的程序设计中function叫做函数，在面向对象中function则被称之为方法。
同属性一样，类的方法也具有public，protected 以及 private 的访问控制。
访问控制的关键字代表的意义为：
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(); //结果为“汽车”
5.PHP类和对象之构造函数和析构函数
PHP5可以在类中使用__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); //销毁时会调用析构函数
6.PHP类和对象之Static静态关键字
静态属性与方法可以在不实例化类的情况下调用，直接使用类名::方法名的方式进行调用。静态属性不允许对象使用->操作符调用。
class Car {
private static $speed = 10;
public static function getSpeed() {
return self::$speed;
}
}
echo Car::getSpeed(); //调用静态方法
静态方法也可以通过变量来进行动态调用
$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()；
7.PHP类和对象之访问控制
访问控制通过关键字public，protected和private来实现。被定义为公有的类成员可以在任何地方被访问。被定义为受保护的类成员则可以被其自身以及其子类和父类访问。被定义为私有的类成员则只能被其定义所在的类访问。
类属性必须定义为公有、受保护、私有之一。为兼容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(); //通过静态方法来获得一个实例
8、PHP类和对象之对象继承
继承是面向对象程序设计中常用的一个特性，汽车是一个比较大的类，我们也可以称之为基类，除此之外，汽车还分为卡车、轿车、东风、宝马等，因为这些子类具有很多相同的属性和方法，可以采用继承汽车类来共享这些属性与方法，实现代码的复用。
9、PHP类和对象之重载
PHP中的重载指的是动态的创建属性与方法，是通过魔术方法来实现的。属性的重载通过__set，__get，__isset，__unset来分别实现对不存在属性的赋值、读取、判断属性是否设置、销毁属性。
class Car {
private $ary = array();
public function __set($key, $val) {
$this->ary[$key] = $val;
}
public function __get($key) {
if (isset($this->ary[$key])) {
return $this->ary[$key];
}
return null;
}
public function __isset($key) {
if (isset($this->ary[$key])) {
return true;
}
return false;
}
public function __unset($key) {
unset($this->ary[$key]);
}
}
$car = new Car();
$car->name = '汽车'; //name属性动态创建并赋值
echo $car->name;
方法的重载通过__call来实现，当调用不存在的方法的时候，将会转为参数调用__call方法，当调用不存在的静态方法时会使用__callStatic重载。
class Car {
public $speed = 0;
public function __call($name, $args) {
if ($name == 'speedUp') {
$this->speed += 10;
}
}
}
$car = new Car();
$car->speedUp(); //调用不存在的方法会使用重载
echo $car->speed;
10、PHP类和对象之对象的高级特性
对象比较，当同一个类的两个实例的所有属性都相等时，可以使用比较运算符==进行判断，当需要判断两个变量是否为同一个对象的引用时，可以使用全等运算符===进行判断。
class Car {
}
$a = new Car();
$b = new Car();
if ($a == $b) echo '=='; //true
if ($a === $b) echo '==='; //false
对象复制，在一些特殊情况下，可以通过关键字clone来复制一个对象，这时__clone方法会被调用，通过这个魔术方法来设置属性的值。
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;
var_dump($b);
对象序列化，可以通过serialize方法将对象序列化为字符串，用于存储或者传递数据，然后在需要的时候通过unserialize将字符串反序列化成对象进行使用。
class Car {
public $name = 'car';
}
$a = new Car();
$str = serialize($a); //对象序列化成字符串
echo $str.'
';
$b = unserialize($str); //反序列化为对象
var_dump($b);
11.include和require
include() 语句将在其被调用的位置处包含一个文件
include_once()的作用与include()相同，不过它会首先验证是否已经包含了该文件，如果已经包含，则不再执行include_once()
include "031.php";//引入php文件
include "033.html";//引入html文件
echo $a;//可以直接取到引用的文件的里面的变量
require()与include()一样，只不过require()我们通常放在php程序的最前面
require_once与include_once()一样，但是也要放在php程序的最前面
include和require的区别：
require一个文件存在错误的话，那么程序就会中断执行了，并显示致命错误
include一个文件存在错误的话，那么程序不会中断，而是继续执行，并显示一个警告错误。
include （或 require）语句会获取指定文件中存在的所有文本/代码/标记，并复制到使用 include 语句的文件中。
包含文件很有用，如果您需要在网站的多张页面上引用相同的 PHP、HTML 或文本的话。