【夯实PHP基础】PHP数组，字符串，对象等基础面面观

　本文地址

 

　分享提纲

　　1.数组篇

　　2.字符创篇

　　3.函数篇

　　4.面向对象篇

　　5.其他篇

 

 

一、 数组篇

---

 

 1. 从PHP数组中删除一个元素

　　1）unset但是不会重建索引

           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

 

 

 

二、 字符串篇

---

 

1. php中strstr、strrchr、substr、stristr四个函数的区别总结

 

 

 

 

 

 

 

三、 函数篇

---

 

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 
";
    ?>

//输出
    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.

　

 

 

 

 

 

 

 

 

 

 

四、 面向对象篇

---

 

 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'."
";  
    }  
}  
  
//类适配器角色  
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'."
";     
    }   
      
}  
  
//客户端  
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 "
";
$m->ml();
?>

View Code

 

 

 9. 【行为型设计模式】：

1)【 模板方法设计模式】

-- 只需要一个抽象类和一个具体类。

-- 【好莱坞原则】也叫【反向控制原则】：指父类调用子类的操作而子类不调用父类的操作。

-- 可以与工厂模式相结合使用。

--模板方法设计模式中的钩子：

在抽象类中参数即钩子，它可以在子类中有条件的判断是不是执行某些步骤。

php
/**
 * 模板模式
 *
 * 定义一个操作中的算法骨架,而将一些步骤延迟到子类中,使得子类可以不改变一个算法的结构可以定义该算法的某些特定步骤
 *
 */
abstract class TemplateBase
{
    public function Method1()
    {
        echo "abstract Method 
";
    }
 
    public function Method2()
    {
        echo "abstract Method2
";
    }
 
    public function Method3()
    {
        echo "abstract Method3
";
    }
 
    public function doSomeThing()//骨架，上面三个是步骤，可以在子类中延迟实现
    {
        $this->Method1();
        $this->Method2();
        $this->Method3();
    }
}
 
class TemplateObject extends TemplateBase
{
}
 
class TemplateObject1 extends TemplateBase
{
    public function Method3()
    {
        echo "TemplateObject1 Method3
";
    }
}
 
class TemplateObject2 extends TemplateBase
{
    public function Method2()
    {
        echo "TemplateObject2 Method2
";
    }
}
 
// 实例化
$objTemplate = new TemplateObject();
$objTemplate1 = new TemplateObject1();
$objTemplate2 = new TemplateObject2();
 
$objTemplate->doSomeThing();
echo '
';
$objTemplate1->doSomeThing();
echo '
';
$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 "
";
        echo '按下开关之后:';
        $this->state->show();
    }
}
 
//实例化一个电灯，设置初始状态为开
$m = new light();
$m->set(new onstate());
 
//按下开关
$m->puton();
echo "
";
echo '--------------------------------';
echo "
";
$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 "
";
        foreach ($this->contact as $tel){
            $tel->update();
            echo "
";
        }
    }
     
    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 类报告了一个方法的有关信息。

 

 

 五、其他篇

---