一、數組
1、數組定義
數組就是一個鍵值對組成的語言結構，鍵類似于酒店的房間號，值類似于酒店房間里存儲的東西。
$arr=array();表示創建一個空數組，并把創建的空數組賦值給變量$arr。
print_r($arr)打印數組
2、PHP數組之索引數組初始化
php數組，根據索引值的不同分為兩種：索引數組、關聯數組。
索引和關聯兩個詞都是針對數組的鍵而言的。
索引數組是指數組的鍵是整數的數組，并且鍵的整數順序是從0開始，依次類推。
$fruit = array("蘋果","香蕉","菠蘿");注意數組的鍵是從0開始的。可以使用print_r($fruit);語句輸出數組鍵及對應的值。
<?php
$fruit=array("蘋果","香蕉","菠蘿");
print_r($fruit); ? ? ? ? ? ? ? ? ? ? ? //Array([0] => 蘋果[1] => 香蕉[2] => 菠蘿)
?>
3、PHP數組之索引數組賦值
索引數組賦值有三種方式:
第一種：用數組變量的名字后面跟一個中括號的方式賦值，當然，索引數組中，中括號內的鍵一定是整數。比如，$arr[0]='蘋果';
第二種：用array()創建一個空數組，使用=>符號來分隔鍵和值，左側表示鍵，右側表示值。當然，索引數組中，鍵一定是整數。比如，array('0'=>'蘋果');
第三種：用array()創建一個空數組，直接在數組里用英文的單引號'或者英文的雙引號"賦值，數組會默認建立從0開始的整數的鍵。比如array('蘋果');這個數組相當于array('0'=>'蘋果');
4、PHP數組之訪問索引數組內容
有的時候我們需要把數組中的內容也就是值取出來該怎么辦呢？用數組變量的名字后跟的中括號中的鍵，來訪問數組中的值。
<?php
$fruit = array('蘋果','香蕉');
$fruit0 = $fruit['0'];
print_r($fruit0);//結果為蘋果
?>
上面代碼的作用：先把一個數組$fruit第一個值取出來然后賦給一個變量$fruit0，最后輸出變量值。
5、PHP數組之for循環訪問索引數組里的值
for循環可以將數組里的所有值都訪問到，下面我們展示下，用for循環訪問索引數組里的值。
<?php
$fruit=array('蘋果','香蕉','菠蘿');
for($i=0; $i<3; $i++){
echo '<br/>數組第'.$i.'值是：'.$fruit[$i];
}
6、PHP數組之foreach循環訪問索引數組里的值
foreach循環可以將數組里的所有值都訪問到，下面我們展示下，用foreach循環訪問索引數組里的值。
<?php
$fruit=array('蘋果','香蕉','菠蘿');
foreach($fruit as $k=>$v){
echo '<br/>第'.$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 ? ?'<br/>水果的英文鍵名：'.$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 ? "<br/>";
echo ? $v;
}else{
//雙層循環數組
foreach($v ?as ? $kk=>$vv){
echo ? ?"<br/>";
echo ? $vv;}}}
//循環多維數組
//引入文件
include ? "adress.php";
foreach($adress ? as ? $k => $v) {
echo"省名：". $v["province_name"]."<br/>";
if(!empty($v["city"])) {
foreach($v["city"] ? as ? ? $key => $val) {
echo"? ? 市名：". $val["city_name"]."<br/>";
if(!empty($val["area"])) {
foreach($val["area"] ? ?as ? ?$kk => $vv) {
echo"? ? ? ? 區名：". $vv."<br/>";}}}}}
二、函數
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的同名引用或者指針
<?php
$var1 = 1;
$var2 = 2;
function test(){
$GLOBALS[‘var2′] = &$GLOBALS[‘var1′];
}
test();
echo $var2;//正常打印結果為1
?>
<?php
$var1 = 1;
$var2 = 2;
function test(){
global $var1,$var2;
$var2 = &$var1;
}
test();
echo $var2;//意外打印結果為2.為什么會打印結果為2呢？其實就是因為$var1的引用指向了$var2的引用地址。導致實質的值沒有改變。
?>
我們再來看一個例子吧。
<?php
$var1 = 1;
function test(){
unset($GLOBALS[‘var1′]);
}
test();
echo $var1;//因為$var1被刪除了，所以什么東西都沒有打印
?>
<?php
$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();
類與對象看起來比較相似，但實際上有本質的區別，類是抽象的概念，對象是具體的實例。類可以使程序具有可重用性。
<?php
//定義一個類
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.'<br/>';
$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 或文本的話。
