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

 正文地址

 

 分享提纲

  1.数组篇

  2.字符创篇

  3.函数篇

  4.面向对象篇

  5.其他篇

 

 

一、 数组篇


 

 1.
从PHP数组中除去一个因素

  1)unset不过不会重建索引

          
array_splice() 会重建索引

 

2.
【输入数组中某个单一列的值】

  1)array_column()

  

图片 1图片 2

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

 

  1. 【数组的联合 array_merge】

  1) 自己的阅历

图片 3图片 4

1. 数组的合并
array_merge() 会重置键名
arrar1 + array2 会保留原来键名

2. 数组的切割
arrar_slice() 会重置键名
array_slice($dealDatas, $start, $length, true); 第4个参数是 true,会保留键名

View Code

 

  1. 【英文字符转时间戳 strtotime()】

图片 5图片 6

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

               1) 输出 2016-10-30日的前两天的 21点后的时间戳

View Code

 

 

 

二、 字符串篇


 

1.
phpstrstr、strrchr、substr、stristr两个函数的分别总计

 

 

 

 

 

 

 

三、 函数篇


 

1.
register_shutdown_function()】:register_shutdown_function()函数可实现当程序执行完成后实施的函数,其效果为可实现程序执行完成的继续操作

图片 7图片 8

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

 

  1. PHP Math
    函数

图片 9图片 10

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新特性 

图片 11图片 12

<?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 和 类名
的品类阐明,其他任何标量类型的宣示都是不辅助的,比如下下面的代码都将发出错误

图片 13图片 14

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() 方法来贯彻,克隆不会启动构造函数。

图片 15图片 16

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

View Code

 8. 【结构型设计形式】

  结构型设计模式探究的是如何结合对象和类来整合更大的结构。

  1)【适配器情势】:

    适配器形式有两种:对象适配器和类适配器

    对象适配器使用的是整合而不是继承,类适配器使用的是持续而不是结合。

    适配器(Mobile艾达(Ada)pter)插足者’包装了’
被适配者(Mobile)参预者,使适配器能够运用同一的接口。    

图片 17图片 18

//目标角色  
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)【装饰器情势】:

    – 使用时机:想为现有对象扩展新职能,又不影响另外对象

    – 定义:对已部分’结构’扩充装饰,向现有的目的扩大对象

图片 19图片 20

<?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)

    – 定义:为其他对象提供一种代理以控制对这个对象的访问

    

图片 21图片 22

<?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. 【行为型设计情势】

1)【模板方法设计模式

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


【好莱坞原则】也叫【反向决定规范】:指父类调用子类的操作而子类不调用父类的操作。

— 可以与工厂形式相结合使用。

–模板方法设计形式中的钩子:

在抽象类中参数即钩子,它能够在子类中有规范的判断是不是举行某些步骤。

图片 23图片 24

<?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)`` 环境类,就是具体的事物,此例中的电灯。必须包含一个状态实例

    –状态机:使用状态图来举办辨析

    – 应用场景:状态格局很多用到在模拟器和娱乐中

    

图片 25图片 26

<?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)【策略模式】:

    – 定义: 义一名目繁多的算法,把每一个算法封装起来,
并且使它们可相互替换。本格局使得算法可独自于选拔它的客户而变更。是一种表现情势

    – 和 状态格局的类图基本一致,只是 区别如下:

      策略形式是 算法会变化,上下文
配置为现实的策略对象,即这是一个封装的算法。

      状态格局 是意况会生成,上下文
维护子类当前境况的一个实例(定义了眼前的情形)

     

图片 27图片 28

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

    

图片 29图片 30

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

 

图片 31图片 32

<?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 类报告了一个方法的有关信息。

 

 

 五、其他篇


 

相关文章