php

 

lashes：斜线   stripslashes：去掉斜线     argument：参数    construct：构造    destruct：析构（销毁）

extends：继承   access：访问     variable：变量     constant：常量    convert：转换

interface：接口    implements：实现    abstract：抽象类    convention：惯例     extra：扩展        paginate：分页

 

thinkphp

---

 

依赖注入：向方法中注入一个对象参数，并自动实例化

class Demo1
{
    /**
     * \app\common\Temp: 类型限制，$temp参数必须是 \app\common\Temp类 的对象，并且会自动实例化
     */
    public function getMethod(\app\common\Temp $temp)
    {
        $temp->setName('PHP中文网');
        return $temp->getName();
    }
}

 

 

动态配置：对当前控制器或者是某个方法里边进行动态的配置设置

namespace app\index\controller;

class Index
{
    public function __construct()
    {
        config('before', 'beforeAction');
    }

    public function index()
    {
        config('indexAction', 'index');

        dump(config());
    }

    public function demo()
    {
       dump(config());
    }
}

　　

 

---

 

 

接口类

接口是类的模板，类是对象的模板

方法在接口里边是不做具体的实现的

interface Person
{
    public function eat();
    public function sleep();
}

class Man implements Person
{
    public function eat()
    {
        echo '吃海鲜大餐...';
    }

    public function sleep()
    {
        echo '半夜睡觉....';
    }
}

class Woman implements Person
{
    public function eat()
    {
        echo '吃减法水果...';
    }

    public function sleep()
    {
        echo '9点睡觉....';
    }
}

class L
{
    public static function factory(Person $user)  //Person做为类型限制，必须是实现了Person接口的类的对象
    {
        return $user;
    }
}


$user = L::factory(new Woman());

$user->eat();
$user->sleep();

　　

 

 

对象的复制是浅拷贝（地址传递，指向同一个内存，同一个值，这样省内存）
普通类型的变量复制是深拷贝（变量之间通过复制值来进行的）

class A
{
    public $age = 0;
    public $username = '';

    //对象属性
    public $obj = null;
}

$a = new A();

$b = $a;
//$b = clone $a;       //输出0    复制一份变量a的 值 ，给变量b

$b->age = 1;

var_dump($a->age);    //1

 

 

当不能访问(找不到)属性或方法的时候，程序先看下有没有对应魔术方法，来执行魔术方法

__set

__get

__isset

__unset

__call

__callStatic

__invoke

__toString

 

 

命名空间 + 类名 = 类文件的路径

imooc.php

<?php

namespace models;

class Imooc
{
    public function nice()
    {
        echo 'imooc nice';
    }
}

main.php

<?php

spl_autoload_register(function($className) {                 // $className 等于 models\Imooc
       require str_replace('\\', '/', $className . '.php');  // 把'\'替换为'/'在$className . '.php'里边
});

$imooc = new models\Imooc();

var_dump(
    $imooc
);

 

 

 

 

$this 等于类即将生成的对象，对象不能访问类里边的常量（故$this也不能），通过对象来调用类中的属性和方法
self 等于这个类，可通过self::访问他的常量，通过 类:: 来调用类中的常量

调用类中的属性和方法——对象(类外边)/$this(类里边)；

调用类中的常量——类::(类外边)/self::(类里边)

 

class Compute {
    const ONE = 1;
    const TWO = self::ONE + 1;
    //const TWO = $this->ONE + 1   错误

    public $cpu = 'amd 4000';
}

var_dump(
    Compute::TWO
);

$compute = new Compute();
var_dump(
    $compute->cpu
);

 

静态属性或方法、类常量：属于类（而不属于对象），外部通过 类名:: 调用，内部通过self:: 访问

class Person
{
    public static $hand = '手';
    public static $food = '脚';

    public $a = 1;            //a属于对象

    const TWO = 2;

    public static function work()
    {
        echo(self::$hand);    //手
        echo(self::TWO);      //2
      //echo(self::$a);       //错误，a属于对象，不属于类，不能用self::
      //echo($this->a);       //也错误，静态work()方法属于类，不属于对象，所以work()里边根本没有$this的上下文
    }

}

$person = new Person();

echo(Person::work());

parent：父类本身

self：类本身

this：类的对象

 

 

后期静态绑定

<?php

class A
{
    public static function who()
    {
        echo 'A类的who方法';
    }

    public static function test()
    {
        static::who();   //运行的时候，根据上下文来判断，这个static到底指向的是哪个类
　　　 //self::who();     //结果输出：A类的who方法， self就是A这个类，不是B类
    }
}

class B extends A
{
    public static function who()
    {
        echo 'B类的who方法';
    }
}

B::test();       //B类的who方法

 

 

 

heredoc 定义字符串：

<?php

$track_name = '海阔天空';
$band_name = 'Beyond';

$doc = <<< HEREDOC
$track_name: 好比你在DreamWeaver里做一个网页，在源代码里按一下回车，\r\n是给源代码回车换行。-$band_name
HEREDOC;

echo $doc;

//海阔天空: 好比你在DreamWeaver里做一个网页，在源代码里按一下回车， 是给源代码回车换行。-Beyond