【夯實PHP基礎】PHP數組，字符串，對象等基礎面面觀

時間  2019-12-13
標籤 夯實PHP基礎 php 數組 字符串 對象 基礎 面面觀 欄目 PHP 简体版
原文   原文鏈接

　本文地址php

 

　分享提綱html

　　1.數組篇算法

　　2.字符創篇數據庫

　　3.函數篇編程

　　4.面向對象篇設計模式

　　5.其餘篇數組

 

 

1、 數組篇

 

 1. 從PHP數組中刪除一個元素app

　　1）unset可是不會重建索引
ide

           array_splice() 會重建索引函數

 

2. 【輸入數組中某個單一列的值】

　　1）array_column()

　　

<?php
// 表示由數據庫返回的可能記錄集的數組
$a = array(
  array(
    'id' => 5698,
    'first_name' => 'Bill',
    'last_name' => 'Gates',
  ),
  array(
    'id' => 4767,
    'first_name' => 'Steve',
    'last_name' => 'Jobs',
  )
  array(
    'id' => 3809,
    'first_name' => 'Mark',
    'last_name' => 'Zuckerberg',
  )
);

$last_names = array_column($a, 'last_name', 'id');
print_r($last_names);
?>
View Code

 

3. 【數組的合併 array_merge】

　　1) 本身的經驗

1. 數組的合併
array_merge() 會重置鍵名
arrar1 + array2 會保留原來鍵名

2. 數組的切割
arrar_slice() 會重置鍵名
array_slice($dealDatas, $start, $length, true); 第4個參數是 true，會保留鍵名
View Code

 

4. 【英文字符轉時間戳 strtotime()】

    //php -r 'echo strtotime("-2 days +21 hours", strtotime("2016-10-30"));'  

               1) 輸出 2016-10-30日的前兩天的 21點後的時間戳
View Code

 

 

 

2、 字符串篇

 

1. php中strstr、strrchr、substr、stristr四個函數的區別總結

 

 

 

 

 

 

 

3、 函數篇

 

1. 【register_shutdown_function()】:register_shutdown_function() 函數可實現當程序執行完成後執行的函數，其功能爲可實現程序執行完成的後續操做

    <?php
        class ClassDemo {
            public function __construct() {
                register_shutdown_function(array($this, "f"));
            }
     
            public function f() {
                echo "f()";
            }
        }
     
        $demo = new ClassDemo();
        echo "before </br>";
    ?>

//輸出
    before
    f()
View Code

 

2. 【PHP Math 函數】

1）decbin() 函數把十進制轉換爲二進制
2）pow() 函數返回 x 的 y 次方。
3）abs()  絕對值。
4）bindec() 把二進制轉換爲十進制
5）ceil()  向上舍入爲最接近的整數
6）floor() 向下舍入爲最接近的整數。
7）max() 返回最大值
8）min()  返回最小值
9）rand() 返回隨機整數
10）round()  對浮點數進行四捨五入
11)array_shift() 函數刪除數組中第一個元素，並返回被刪除元素的值
View Code

 

3.

　

 

 

 

 

 

 

 

 

 

 

4、 面向對象篇

 

 1. 【對象做爲屬性】：可使用一個A類做爲另外一個B類的屬性，經過實例化B類，來到達使用A類的屬性和函數的目的，同時，能夠在B類中對獲取到的A類的數據，進行修改和處理，而不影響A類自己

 2. 【解決PHP的單繼承】： Trait相似於類，可是不能被本身實例化  PHP的學習--Traits新特性 

<?php
trait Hello {
    public function sayHello() {
        echo 'Hello ';
    }
}

trait World {
    public function sayWorld() {
        echo 'World!';
    }
}

trait HelloWorld {
    use Hello, World;
}

class MyHelloWorld {
    use HelloWorld;
}

$o = new MyHelloWorld();
$o->sayHello();
$o->sayWorld();
?>
View Code

 3. 【interface】: 接口 interface中不能包含變量，可是能夠包含常量，實現(implements) 接口的類，必須實現接口的全部方法，而後能夠額外添加本身的屬性和方法。

 4.【類型提示】：PHP只支持兩種類型array 和 類名 的類型聲明,其餘任何標量類型的聲明都是不支持的，好比下下面的代碼都將產生錯誤

function demo(string $str){
}
$str="hello";
demo($str)

當咱們運行上面的代碼時，string會被當作類名稱對待，所以會報下面的錯誤:
Catchable fatal error: Argument 1 passed to demo() must be an instance of string, string given,
View Code

 5.【變量數據類型】：在PHP中，不能聲明一個變量的數據類型爲抽象父類(抽象類或接口)，由於若是不實例化一個類實例，就不能聲明數據類型。雖然別的強類型的語言能夠

 6.【設計模式 原則】：

　　1)按照接口編程而不是實現編程(對PHP來講指的是類的接口，而不是使用關鍵字 interface定義的接口接口--參見《learing php設計模式》page 51)

　　2)應當優先使用對象組合而不是類繼承

 

7.【clone 實現原型模式】：

　　php 可使用 __clone() 方法來實現,克隆不會啓動構造函數。

$objOne = new YourObj();
$objOne = clone objOne;
View Code

 8. 【結構型設計模式】：

　　結構型設計模式研究的是如何組合對象和類來構成更大的結構。

　　1）【適配器模式】：

　　　　適配器模式有兩種：對象適配器和類適配器。

　　　　對象適配器使用的是組合而不是繼承，類適配器使用的是繼承而不是組合。

　　　　適配器(MobileAdapter)參與者'包裝了' 被適配者(Mobile)參與者，使適配器可使用一樣的接口。　　　　

//目標角色  
interface Target {  
    public function simpleMethod1();  
    public function simpleMethod2();  
}  
  
//源角色  
class Adaptee {  
      
    public function simpleMethod1(){  
        echo 'Adapter simpleMethod1'."<br>";  
    }  
}  
  
//類適配器角色  
class Adapter implements Target {  
    private $adaptee;  
      
      
    function __construct(Adaptee $adaptee) {  
        $this->adaptee = $adaptee;   
    }  
      
    //委派調用Adaptee的sampleMethod1方法  
    public function simpleMethod1(){  
        echo $this->adaptee->simpleMethod1();  
    }  
      
    public function simpleMethod2(){  
        echo 'Adapter simpleMethod2'."<br>";     
    }   
      
}  
  
//客戶端  
class Client {  
      
    public static function main() {  
        $adaptee = new Adaptee();  
        $adapter = new Adapter($adaptee);  
        $adapter->simpleMethod1();  
        $adapter->simpleMethod2();   
    }  
}  
  
Client::main();
View Code

 

　　2）【裝飾器模式】：

　　　　-- 使用時機：想爲現有對象增長新功能，又不影響其餘對象

　　　　-- 定義：對已有的'結構'增長裝飾，向現有的對象增長對象

<?php
abstract class Beverage{
    public $_name;
    abstract public function Cost();
}
// 被裝飾者類
class Coffee extends Beverage{
    public function __construct(){
        $this->_name = 'Coffee';
    }   
    public function Cost(){
        return 1.00;
    }   
}
// 如下三個類是裝飾者相關類
class CondimentDecorator extends Beverage{
    public function __construct(){
        $this->_name = 'Condiment';
    }   
    public function Cost(){
        return 0.1;
    }   
}
 
class Milk extends CondimentDecorator{
    public $_beverage;
    public function __construct($beverage){
        $this->_name = 'Milk';
        if($beverage instanceof Beverage){
            $this->_beverage = $beverage;
        }else
            exit('Failure');
    }   
    public function Cost(){
        return $this->_beverage->Cost() + 0.2;
    }   
}
 
class Sugar extends CondimentDecorator{
    public $_beverage;
    public function __construct($beverage){
        $this->_name = 'Sugar';
        if($beverage instanceof Beverage){
            $this->_beverage = $beverage;
        }else{
            exit('Failure');
        }
    }
    public function Cost(){
        return $this->_beverage->Cost() + 0.2;
    }
}
 
// Test Case
//1.拿杯咖啡
$coffee = new Coffee();
 
//2.加點牛奶
$coffee = new Milk($coffee);
 
//3.加點糖
$coffee = new Sugar($coffee);
 
printf("Coffee Total:%0.2f元\n",$coffee->Cost());
View Code

 

　　3）【包裝器】

　　　　-- 適配器和裝飾器模式都有另一個名字 "包裝器"(wrapper)

 

　　4）【代理模式】

　　　　-- 4種代理模式：遠程代理， 虛擬代理， 保護代理， 智能引用

　　　　-- 2個主要參與者：代理主題(proxy subject) , 真實主題(real subject)

　　　　-- 定義：爲其餘對象提供一種代理以控制對這個對象的訪問

　　　　

<?php
/*
 * 代理模式
 * 爲其餘對象提供一種代理以控制對這個對象的訪問。
 * 在某些狀況下，一個對象不適合或者不能直接引用另外一個對象，而代理對象能夠在客戶端和目標對象之間起到中介的做用。
 * 王婆就是西門慶跟潘金蓮的代理。西門慶是客戶端，潘金蓮是對象自己。
 */
 
interface women{
    public function ml();
    public function say();
}
 
class pjl implements women{
    public function say(){
        echo 'I am panjinlian,i want to  ml with man';
    }
    public function ml(){
        echo 'hehe';
    }
}
 
class wangpo implements women{
    public $a;
    public function __construct(){
        $this->a = new pjl();
    }
     
    public function say(){
        $this->a->say();
    }
    public function ml(){
        $this->a->ml();
    }
}
 
$m = new wangpo();
$m->say();
echo "<br/>";
$m->ml();
?>
View Code

 

 

 9. 【行爲型設計模式】：

-- 只須要一個抽象類和一個具體類。
-- 【好萊塢原則】也叫【反向控制原則】：指父類調用子類的操做而子類不調用父類的操做。
-- 能夠與工廠模式相結合使用。
--模板方法設計模式中的鉤子：
在抽象類中參數即鉤子，它能夠在子類中有條件的判斷是否是執行某些步驟。 
<?php
/**
 * 模板模式
 *
 * 定義一個操做中的算法骨架,而將一些步驟延遲到子類中,使得子類能夠不改變一個算法的結構能夠定義該算法的某些特定步驟
 *
 */
abstract class TemplateBase
{
    public function Method1()
    {
        echo "abstract Method <br/>";
    }
 
    public function Method2()
    {
        echo "abstract Method2<br/>";
    }
 
    public function Method3()
    {
        echo "abstract Method3<br/>";
    }
 
    public function doSomeThing()//骨架，上面三個是步驟，能夠在子類中延遲實現
    {
        $this->Method1();
        $this->Method2();
        $this->Method3();
    }
}
 
class TemplateObject extends TemplateBase
{
}
 
class TemplateObject1 extends TemplateBase
{
    public function Method3()
    {
        echo "TemplateObject1 Method3<br/>";
    }
}
 
class TemplateObject2 extends TemplateBase
{
    public function Method2()
    {
        echo "TemplateObject2 Method2<br/>";
    }
}
 
// 實例化
$objTemplate = new TemplateObject();
$objTemplate1 = new TemplateObject1();
$objTemplate2 = new TemplateObject2();
 
$objTemplate->doSomeThing();
echo '<br />';
$objTemplate1->doSomeThing();
echo '<br />';
$objTemplate2->doSomeThing();
?>
View Code

 

　　2)【狀態模式】：

　　　　--定義：容許一個對象在其內部狀態改變時改變它的行爲。對象看起來彷佛修改了它的類。（行爲模式）

　　　　-- 三要素：

　　　　　　　 a) 抽象狀態接口，全部具體狀態實現此接口。

 　　　　　　　b) 具體狀態，有幾個狀態就有幾個類，分別表明不一樣的狀態
 　　　　　　　c) 環境類，就是具體的事物，此例中的電燈。必須包含一個狀態實例
　　　　--狀態機：使用 狀態圖來進行分析
　　　　-- 應用場景：狀態模式不少應用在模擬器和遊戲中

　　　　

<?php
/*狀態模式：容許一個對象在其內部狀態改變時改變它的行爲。對象看起來彷佛修改了它的類。（行爲模式）
 *
 * 在不少狀況下，一個對象的行爲取決於一個或多個動態變化的屬性，這樣的屬性叫作狀態，
 * 這樣的對象叫作有狀態的(stateful)對象，這樣的對象狀態是從事先定義好的一系列值中取出的。
 * 當一個這樣的對象與外部事件產生互動時，其內部狀態就會改變，從而使得系統的行爲也隨之發生變化。
 *
 *
 * 三要素：1 抽象狀態接口，全部具體狀態實現此接口。
 * 2: 具體狀態，有幾個狀態就有幾個類，分別表明不一樣的狀態
 * 3 環境類，就是具體的事物，此例中的電燈。必須包含一個狀態實例
 *
 */
 
 
/*
 * 以電燈爲例：電燈對象自己有兩個狀態，開/關， 一個行爲：按下開關。
 * 當電燈的狀態爲開時，按下開關，表現爲關燈；當電燈的狀態爲關時，按下開關，表現爲開燈；典型的狀態改變時，改變了開關的行爲
 *
 */
 
//抽象狀態接口
interface state{
    public function show();//展現當前狀態
    public function handle($light);//當前狀態改變時，設置電燈的下一個狀態，操做對象電燈
}
 
//電燈的兩個具體狀態
class onstate implements state{
    public function show(){
        echo '是開燈狀態';
    }
    public function handle($light){
        $light->set(new offstate());
    }
}
 
class offstate implements state{
    public function show(){
        echo '是關燈狀態';
    }
     
    public function handle($light){
        $light->set(new onstate());
    }
}
 
//環境類，電燈。狀態state   行爲puton
class light{
    public $state;
    public function set(state $state){//設置電燈的狀態
        $this->state = $state;
    }
    public function puton(){//行爲
        echo '電燈初始狀態:';
        $this->state->show();
        $this->state->handle($this);
        echo "<br/>";
        echo '按下開關以後:';
        $this->state->show();
    }
}
 
//實例化一個電燈，設置初始狀態爲開
$m = new light();
$m->set(new onstate());
 
//按下開關
$m->puton();
echo "<br/>";
echo '--------------------------------';
echo "<br/>";
$m->puton();
?>
View Code

 

　　3)【策略模式】：

　　　　-- 定義： 定義一系列的算法,把每個算法封裝起來, 而且使它們可相互替換。本模式使得算法可獨立於使用它的客戶而變化。是一種行爲模式

　　　　-- 和 狀態模式的類圖基本同樣，只是 區別以下：

　　　　　　策略模式是 算法會變化，上下文 配置爲具體的策略對象，即這是一個封裝的算法。

　　　　　　狀態模式 是狀態會變化，上下文 維護子類當前狀態的一個實例(定義了當前的狀態)

 　　　　

 <?php
/*
 * 策略模式：定義一系列算法，而且把每個算法封裝起來，而且使它們能夠相互替換
 * 策略模式使得算法能夠獨立於使用它的客戶而變化
 */
 
 
//抽象策略接口，完成某件事情
interface category{
    public function dosomething();
}
 
//具體算法類，實現具體的事情
class category_a implements category{
    public function dosomething(){
        echo 'do A';
    }
}
 
class category_b implements category{
    public function dosomething(){
        echo 'do B';
    }
}
 
class category_c implements category{
    public function dosomething(){
        echo 'do C';
    }
}
 
//配置類，使用抽象策略接口來配置
class context{
    public $cg;
     
    public function __construct(category $a){
        $this->cg = $a;
    }
     
    public function dodo(){
        return $this->cg->dosomething();//同一方法做用於不一樣類的對象，產生不一樣的結果，這在php中就是多態
    }
}
 
//客戶端調用，由客戶本身決定使用哪一種策略，即客戶自行實例化算法類。區別於簡單工廠模式
//簡單工廠模式是對象的建立模式，客戶端不建立對象，只給出參數，由工廠方法來決定建立哪個實例
//也就是說，簡單工廠模式客戶端只傳參數，策略模式客戶端傳算法實例
$m = new context(new category_b());
$m->dodo();
?>

　　上面實現了策略模式。

如今我要增長一種算法，do D；我只須要新寫一個類
1
2
3
4
5
    
class category_d implements category{
    public function dosomething(){
        echo 'do D';
    }
}

　　客戶端調用，替換成d就能夠了
1
    
$m = new context(new category_b());

　　區別於簡單工廠模式（見簡單工廠模式篇）。

 

策略模式缺點：

 客戶端必須知道全部的策略類，並自行決定使用哪個策略類。這就意味着客戶端必須理解這些算法的區別，以便適時選擇恰當的算法類。換言之，策略模式只適用於客戶端知道全部的算法或行爲的狀況。
View Code

 

　　4）【觀察者模式】：

　　　　--定義： 定於對象間的一種一對多的依賴關係，當一個對象發生改變時，全部依賴它的對象都收到通知並自動更新

　　　　-- 闡述：核心在與Subject和Observer接口，相似於'訂閱'了主題，按期收到通知。

　　　　--實現：可使用PHP內置的觀察者接口，即PHP的標準庫SPI的一組接口。

　　　　　　　　有3個，SplSubject, SplObserver, SplObjectStorage

　　　　

<?php
/**
 * 觀察者模式：定於對象間的一種一對多的依賴關係，當一個對象發生改變時，全部依賴它的對象都收到通知並自動更新。
 */
 
//例子：少林方丈的通信錄，當掃地僧的號碼發生變化時，只需告訴方丈，方丈可通知本身通信錄裏面的全部人
interface Contacts{
    public function addTel($tel);
    public function delTel($tel);
    public function notify();
    public function action($action);
}
 
class StuContact implements Contacts{
    public $contact;
    public $action;
    public function addTel($tel){
        $this->contact[] = $tel;
    }
     
    public function delTel($tel){
        $key = array_search($tel, $this->contact);
        if($key !== FALSE){
            unset($this->contact[$key]);
        }else{
            echo '通信錄中無此人';
        }
    }
     
    public function notify(){
        echo $this->action;
        echo "<br/>";
        foreach ($this->contact as $tel){
            $tel->update();
            echo "<br/>";
        }
    }
     
    public function action($action){
        $this->action = $action;
    }
}
 
interface Tel{
    public function update();
}
 
class StuTel implements Tel{
    public $name;
    public function __construct($name){
        $this->name = $name;
    }
     
    public function update(){
        echo $this->name.'收到消息，已經更新';
    }
}
 
class Client{
    public static function main(){
        $tel1 = new StuTel('虛竹');
        $tel2 = new StuTel('喬峯');
        $tel3 = new StuTel('段譽');
         
        $contacts = new StuContact();
        $contacts->addTel($tel1);
        $contacts->addTel($tel2);
        $contacts->addTel($tel3);
         
        $contacts->action('掃地僧的號碼更新了，是11111');
        $contacts->notify();
    }
}
 
Client::main();
?>
View Code

 

<?php
/*
 * 觀察者模式：定義對象間的一種一對多的依賴關係，當一個對象的狀態發生改變時，全部依賴於它的對象都獲得通知並被自動更新。
 * 類型：行爲類模式
 * 
 *
 */
 
//抽象主題角色
interface Subject
{
    public function Attach($Observer); //添加觀察者
    public function Detach($Observer); //踢出觀察者
    public function Notify(); //知足條件時通知觀察者
    public function SubjectState($Subject); //觀察條件
}
 
//具體主題角色
class Boss Implements Subject
{
    public $_action;
    private $_Observer;
    public function Attach($Observer)
    {
        $this->_Observer[] = $Observer;
    }
    public function Detach($Observer)
    {
        $ObserverKey = array_search($Observer, $this->_Observer);
        if($ObserverKey !== false)
        {
            unset($this->_Observer[$ObserverKey]);
        }
    }
    public function Notify()
    {
        foreach($this->_Observer as $value )
        {
            $value->Update();
        }
    }
    public function SubjectState($Subject)
    {
        $this->_action = $Subject;
    }
}
 
//抽象觀察者角色
abstract class Observer
{
    protected $_UserName;
    protected $_Sub;
    public function __construct($Name,$Sub)
    {
        $this->_UserName = $Name;
        $this->_Sub = $Sub;
    }
    public abstract function Update(); //接收經過方法
}
//具體觀察者角色
class StockObserver extends Observer
{
    public function __construct($name,$sub)
    {
        parent::__construct($name,$sub);
    }
    public function Update()
    {
        echo $this->_Sub->_action.$this->_UserName." 你趕快跑...";
    }
}
$huhansan = new Boss(); //被觀察者
$gongshil = new StockObserver("三毛",$huhansan); //初始化觀察者
$huhansan->Attach($gongshil); //添加一個觀察者
$huhansan->Attach($gongshil); //添加一個相同的觀察者
//$huhansan->Detach($gongshil); //踢出基中一個觀察者
$huhansan->SubjectState("警察來了"); //達到知足的條件
$huhansan->Notify(); //經過全部有效的觀察者
?>
View Code

 

  10. 【反射】：

　　1）【類相關信息】該擴展分析php程序，導出或提取出關於類、方法、屬性、參數等的詳細信息，包括註釋。
　　2）【擴展】）Reflection能夠說是對php庫函數：「Classes/Objects 類／對象函數」的一個擴展。
　　3）【做用】主要用在經過程序檢測現有php程序內部關於類、方法等信息，並作出處理

　　4）【舉例】ReflectionMethod 是PHP的一個反射類，http://www.php.net/manual/zh/class.reflectionmethod.php    

　　　　　　　 ReflectionMethod 類報告了一個方法的有關信息。

 

 

 5、其餘篇

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程